langgraph-api 0.0.32__tar.gz → 0.0.33__tar.gz

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.32
+Version: 0.0.33
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/api/__init__.py

@@ -10,6 +10,7 @@ from starlette.responses import HTMLResponse, JSONResponse, Response
 from starlette.routing import BaseRoute, Mount, Route
 
 from langgraph_api.api.assistants import assistants_routes
+from langgraph_api.api.mcp import mcp_routes
 from langgraph_api.api.meta import meta_info, meta_metrics
 from langgraph_api.api.openapi import get_openapi_spec
 from langgraph_api.api.runs import runs_routes
@@ -66,6 +67,11 @@ if HTTP_CONFIG:
         protected_routes.extend(store_routes)
     if not HTTP_CONFIG.get("disable_ui"):
         protected_routes.extend(ui_routes)
+    # Default for disabling MCP. Until we can verify that the protocol is working
+    # correctly. This is dependent on the release of an official MCP client
+    # implementation.
+    if not HTTP_CONFIG.get("disable_mcp", True):
+        protected_routes.extend(mcp_routes)
 else:
     protected_routes.extend(assistants_routes)
     protected_routes.extend(runs_routes)

langgraph_api-0.0.33/langgraph_api/api/mcp.py

@@ -0,0 +1,467 @@
+"""Implement MCP endpoint for Streamable HTTP protocol.
+
+The current version of the RFC can be found here:
+
+https://github.com/modelcontextprotocol/specification/blob/0f4924b07447073cbe1e29fbe64e42d379b52b04/docs/specification/draft/basic/transports.md#streamable-http
+
+Tools specification:
+
+https://github.com/modelcontextprotocol/specification/blob/0f4924b07447073cbe1e29fbe64e42d379b52b04/docs/specification/draft/server/tools.md
+
+Message format:
+
+https://github.com/modelcontextprotocol/specification/blob/0f4924b07447073cbe1e29fbe64e42d379b52b04/docs/specification/draft/basic/messages.md
+
+Error handling with tools:
+
+https://github.com/modelcontextprotocol/specification/blob/0f4924b07447073cbe1e29fbe64e42d379b52b04/docs/specification/draft/server/tools.md#error-handling
+
+Streamable HTTP is a protocol that allows for the use of HTTP as transport.
+
+The protocol supports both stateless and stateful interactions, and allows
+the server to respond via either Application/JSON or text/event-stream.
+
+LangGraph's implementation is currently stateless and only uses Application/JSON.
+
+1. Adding stateful sessions: A stateful session would in theory allow agents used
+as tools to remember past interactions. We likely do not want to map a session
+to a thread ID as a single session may involve more than one tool call.
+We would need to map a session to a collection of threads.
+
+2. text/event-stream (SSE): Should be simple to add we'd want to make sure
+we know what information we want to stream; e.g., progress notifications or
+custom notifications.
+
+In addition, the server could support resumability by allowing clients to specify
+a Last-Event-ID in the request headers.
+"""
+
+import functools
+import json
+from typing import Any, NotRequired, cast
+
+from langgraph_sdk.client import LangGraphClient, get_client
+from starlette.responses import JSONResponse, Response
+from structlog import getLogger
+from typing_extensions import TypedDict
+
+from langgraph_api.route import ApiRequest, ApiRoute
+
+logger = getLogger(__name__)
+
+
+class JsonRpcErrorObject(TypedDict):
+    code: int
+    message: str
+    data: NotRequired[Any]
+
+
+class JsonRpcRequest(TypedDict):
+    jsonrpc: str  # Must be "2.0"
+    id: str | int
+    method: str
+    params: NotRequired[dict[str, Any]]
+
+
+class JsonRpcResponse(TypedDict):
+    jsonrpc: str  # Must be "2.0"
+    id: str | int
+    result: NotRequired[dict[str, Any]]
+    error: NotRequired[JsonRpcErrorObject]
+
+
+class JsonRpcNotification(TypedDict):
+    jsonrpc: str  # Must be "2.0"
+    method: str
+    params: NotRequired[dict[str, Any]]
+
+
+@functools.lru_cache(maxsize=1)
+def _client() -> LangGraphClient:
+    """Get a client for local operations."""
+    return get_client(url=None)
+
+
+# Workaround assistant name not exposed in the Assistants.search API
+MAX_ASSISTANTS = 1000
+DEFAULT_PAGE_SIZE = 100
+
+# JSON-RPC error codes: https://www.jsonrpc.org/specification#error_object
+ERROR_CODE_INVALID_PARAMS = -32602
+ERROR_CODE_METHOD_NOT_FOUND = -32601
+
+
+async def handle_mcp_endpoint(request: ApiRequest) -> Response:
+    """MCP endpoint handler the implements the Streamable HTTP protocol.
+
+    The handler is expected to support the following methods:
+
+    - POST: Process a JSON-RPC request
+    - DELETE: Terminate a session
+
+    We currently do not support:
+    - /GET (initiates a streaming session)
+        This endpoint can be used to RESUME a previously interrupted session.
+    - text/event-stream (streaming) response from the server.
+
+    Support for these can be added, we just need to determine what information
+    from the agent we want to stream.
+
+    One possibility is to map "custom" stream mode to server side notifications.
+
+    Args:
+        request: The incoming request object
+
+    Returns:
+        The response to the request
+    """
+    # Route request based on HTTP method
+    if request.method == "DELETE":
+        return handle_delete_request()
+    elif request.method == "GET":
+        return handle_get_request()
+    elif request.method == "POST":
+        return await handle_post_request(request)
+    else:
+        # Method not allowed
+        return Response(status_code=405)
+
+
+def handle_delete_request() -> Response:
+    """Handle HTTP DELETE requests for session termination.
+
+    Returns:
+        Response with appropriate status code
+    """
+    return Response(status_code=404)
+
+
+def handle_get_request() -> Response:
+    """Handle HTTP GET requests for streaming (not currently supported).
+
+    Returns:
+        Method not allowed response
+    """
+    # Does not support streaming at the moment
+    return Response(status_code=405)
+
+
+async def handle_post_request(request: ApiRequest) -> Response:
+    """Handle HTTP POST requests for JSON-RPC messaging.
+
+    Args:
+        request: The incoming request object
+
+    Returns:
+        Response to the JSON-RPC message
+    """
+    body = await request.body()
+
+    # Validate JSON
+    try:
+        message = json.loads(body)
+    except json.JSONDecodeError:
+        return create_error_response("Invalid JSON", 400)
+
+    # Validate Accept header
+    if not is_valid_accept_header(request):
+        return create_error_response(
+            "Accept header must include application/json or text/event-stream", 400
+        )
+
+    # Validate message format
+    if not isinstance(message, dict):
+        return create_error_response("Invalid message format.", 400)
+
+    # Determine message type and route to appropriate handler
+    id_ = message.get("id")
+    method = message.get("method")
+
+    # Check for required jsonrpc field
+    if message.get("jsonrpc") != "2.0":
+        return create_error_response(
+            "Invalid JSON-RPC message. Missing or invalid jsonrpc version.", 400
+        )
+
+    if id_ and method:
+        # JSON-RPC request
+        return await handle_jsonrpc_request(request, cast(JsonRpcRequest, message))
+    elif id_:
+        # JSON-RPC response
+        return handle_jsonrpc_response(cast(JsonRpcResponse, message))
+    elif method:
+        # JSON-RPC notification
+        return handle_jsonrpc_notification(cast(JsonRpcNotification, message))
+    else:
+        # Invalid message format
+        return create_error_response(
+            "Invalid message format. A message is to be either a JSON-RPC "
+            "request, response, or notification."
+            "Please see the Messages section of the Streamable HTTP RFC "
+            "for more information.",
+            400,
+        )
+
+
+def is_valid_accept_header(request: ApiRequest) -> bool:
+    """Check if the Accept header contains supported content types.
+
+    Args:
+        request: The incoming request
+
+    Returns:
+        True if header contains application/json or text/event-stream
+    """
+    accept_header = request.headers.get("Accept", "")
+    accepts_json = "application/json" in accept_header
+    accepts_sse = "text/event-stream" in accept_header
+    return accepts_json or accepts_sse
+
+
+def create_error_response(message: str, status_code: int) -> Response:
+    """Create a JSON error response.
+
+    Args:
+        message: The error message
+        status_code: The HTTP status code
+
+    Returns:
+        JSON response with error details
+    """
+    return Response(
+        content=json.dumps({"error": message}),
+        status_code=status_code,
+        media_type="application/json",
+    )
+
+
+async def handle_jsonrpc_request(
+    request: ApiRequest,
+    message: JsonRpcRequest,
+) -> Response:
+    """Handle JSON-RPC requests (messages with both id and method).
+
+    Args:
+        request: The incoming request object
+        message: The parsed JSON-RPC message
+
+    Returns:
+        Response to the request
+    """
+    method = message["method"]
+    params = message.get("params", {})
+
+    if method == "initialize":
+        result_or_error = handle_initialize_request(message)
+    elif method == "tools/list":
+        result_or_error = await handle_tools_list(request, params)
+    elif method == "tools/call":
+        result_or_error = await handle_tools_call(request, params)
+    else:
+        result_or_error = {
+            "error": {
+                "code": ERROR_CODE_METHOD_NOT_FOUND,
+                "message": f"Method not found: {method}",
+            }
+        }
+
+    # Process the result or error output
+    exists = {"error", "result"} - set(result_or_error.keys())
+    if len(exists) != 1:
+        raise AssertionError(
+            "Internal server error. Invalid response in MCP protocol implementation."
+        )
+
+    return JSONResponse(
+        {
+            "jsonrpc": "2.0",
+            "id": message["id"],
+            **result_or_error,
+        }
+    )
+
+
+def handle_initialize_request(message: JsonRpcRequest) -> dict[str, Any]:
+    """Handle initialize requests to create a new session.
+
+    Args:
+        message: The JSON-RPC request message
+
+    Returns:
+        Response with new session details
+    """
+    return {
+        "result": {
+            # We do not return a session ID right now.
+            "capabilities": {
+                "tools": {
+                    # We do not support subscriptions currently
+                    "listChanged": False,
+                },
+            },
+        },
+    }
+
+
+def handle_jsonrpc_response(message: JsonRpcResponse) -> Response:
+    """Handle JSON-RPC responses (messages with id but no method).
+
+    Args:
+        message: The parsed JSON-RPC response message
+
+    Returns:
+        Acknowledgement response
+    """
+    # For any responses, we just acknowledge receipt
+    return Response(status_code=202)
+
+
+def handle_jsonrpc_notification(message: JsonRpcNotification) -> Response:
+    """Handle JSON-RPC notifications (messages with method but no id).
+
+    Args:
+        message: The parsed JSON-RPC message
+
+    Returns:
+        Response to the notification
+    """
+    return Response(status_code=202)
+
+
+async def handle_tools_list(
+    request: ApiRequest, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Handle tools/list request to get available assistants as tools.
+
+    Args:
+        request: The incoming request object. Used for propagating any headers
+                 for authentication purposes.
+        params: The parameters for the tools/list request
+
+    Returns:
+        Dictionary containing list of available tools
+    """
+    client = _client()
+
+    try:
+        cursor = params.get("cursor", 0)
+        cursor = int(cursor)
+    except ValueError:
+        cursor = 0
+
+    # Get assistants from the API
+    # For now set a large limit to get all assistants
+    assistants = await client.assistants.search(offset=cursor, limit=DEFAULT_PAGE_SIZE)
+
+    if len(assistants) == DEFAULT_PAGE_SIZE:
+        next_cursor = cursor + DEFAULT_PAGE_SIZE
+    else:
+        next_cursor = None
+
+    # Format assistants as tools for MCP
+    tools = []
+    seen_names = set()
+    for assistant in assistants:
+        id_ = assistant.get("assistant_id")
+        name = assistant["name"]
+
+        if name in seen_names:
+            await logger.awarning(f"Duplicate assistant name found {name}", name=name)
+        else:
+            seen_names.add(name)
+
+        schemas = await client.assistants.get_schemas(id_)
+        tools.append(
+            {
+                "name": name,
+                "inputSchema": schemas.get("input_schema", {}),
+                "description": "",
+            },
+        )
+    return {"result": {"tools": tools, "nextCursor": next_cursor}}
+
+
+async def handle_tools_call(
+    request: ApiRequest, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Handle tools/call request to execute an assistant.
+
+    Args:
+        request: The incoming request
+        params: The parameters for the tool call
+
+    Returns:
+        The result of the tool execution
+    """
+    client = _client()
+
+    tool_name = params.get("name")
+
+    if not tool_name:
+        return {
+            "jsonrpc": "2.0",
+            "id": 3,
+            "error": {
+                "code": ERROR_CODE_INVALID_PARAMS,
+                "message": f"Unknown tool: {tool_name}",
+            },
+        }
+
+    arguments = params.get("arguments", {})
+    assistants = await client.assistants.search(limit=MAX_ASSISTANTS)
+    matching_assistant = [
+        assistant for assistant in assistants if assistant["name"] == tool_name
+    ]
+
+    num_assistants = len(matching_assistant)
+
+    if num_assistants == 0:
+        return {
+            "jsonrpc": "2.0",
+            "id": 3,
+            "error": {
+                "code": ERROR_CODE_INVALID_PARAMS,
+                "message": f"Unknown tool: {tool_name}",
+            },
+        }
+    elif num_assistants > 1:
+        return {
+            "jsonrpc": "2.0",
+            "id": 3,
+            "error": {
+                "code": ERROR_CODE_INVALID_PARAMS,
+                "message": "Multiple tools found with the same name.",
+            },
+        }
+    else:
+        tool_name = matching_assistant[0]["assistant_id"]
+
+    value = await client.runs.wait(
+        thread_id=None, assistant_id=tool_name, input=arguments, raise_error=False
+    )
+
+    if "__error__" in value:
+        # This is a run-time error in the tool.
+        return {
+            "result": {
+                "isError": True,
+                "content": [
+                    {"type": "text", "value": value["__error__"]["error"]},
+                ],
+            }
+        }
+
+    # All good, return the result
+    return {
+        "result": {
+            "content": [
+                {"type": "text", "value": repr(value)},
+            ]
+        }
+    }
+
+
+# Define routes for the MCP endpoint
+mcp_routes = [
+    ApiRoute("/mcp", handle_mcp_endpoint, methods=["GET", "POST", "DELETE"]),
+]

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/asyncio.py

@@ -1,4 +1,5 @@
 import asyncio
+import concurrent.futures
 from collections.abc import AsyncIterator, Coroutine
 from contextlib import AbstractAsyncContextManager
 from functools import partial
@@ -10,6 +11,13 @@ T = TypeVar("T")
 
 logger = structlog.stdlib.get_logger(__name__)
 
+_MAIN_LOOP: asyncio.AbstractEventLoop | None = None
+
+
+def set_event_loop(loop: asyncio.AbstractEventLoop) -> None:
+    global _MAIN_LOOP
+    _MAIN_LOOP = loop
+
 
 async def sleep_if_not_done(delay: float, done: asyncio.Event) -> None:
     try:
@@ -76,9 +84,10 @@ PENDING_TASKS = set()
 
 
 def _create_task_done_callback(
-    ignore_exceptions: tuple[Exception, ...], task: asyncio.Task
+    ignore_exceptions: tuple[Exception, ...],
+    task: asyncio.Task | asyncio.Future,
 ) -> None:
-    PENDING_TASKS.remove(task)
+    PENDING_TASKS.discard(task)
     try:
         if exc := task.exception():
             if not isinstance(exc, ignore_exceptions):
@@ -97,6 +106,16 @@ def create_task(
     return task
 
 
+def run_coroutine_threadsafe(
+    coro: Coroutine[Any, Any, T], ignore_exceptions: tuple[type[Exception], ...] = ()
+) -> concurrent.futures.Future[T | None]:
+    if _MAIN_LOOP is None:
+        raise RuntimeError("No event loop set")
+    future = asyncio.run_coroutine_threadsafe(coro, _MAIN_LOOP)
+    future.add_done_callback(partial(_create_task_done_callback, ignore_exceptions))
+    return future
+
+
 class SimpleTaskGroup(AbstractAsyncContextManager["SimpleTaskGroup"]):
     """An async task group that can be configured to wait and/or cancel tasks on exit.
 

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/cli.py

@@ -189,6 +189,7 @@ def run_server(
         LANGSMITH_LANGGRAPH_API_VARIANT="local_dev",
         LANGGRAPH_AUTH=json.dumps(auth) if auth else None,
         LANGGRAPH_HTTP=json.dumps(http) if http else None,
+        LANGGRAPH_API_URL=local_url,
         # See https://developer.chrome.com/blog/private-network-access-update-2024-03
         ALLOW_PRIVATE_NETWORK="true",
         **(env_vars or {}),

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/config.py

@@ -32,6 +32,11 @@ class HttpConfig(TypedDict, total=False):
     disable_meta: bool
     """Disable /ok, /info, /metrics, and /docs routes"""
     cors: CorsConfig | None
+    """CORS configuration"""
+    disable_ui: bool
+    """Disable /ui routes"""
+    disable_mcp: bool
+    """Disable /mcp routes"""
 
 
 class IndexConfig(TypedDict, total=False):

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/graph.py

@@ -21,6 +21,7 @@ from langgraph.pregel import Pregel
 from langgraph.store.base import BaseStore
 from starlette.exceptions import HTTPException
 
+from langgraph_api import asyncio as lg_asyncio
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.schema import Config
 
@@ -60,6 +61,12 @@ async def register_graph(graph_id: str, graph: GraphValue, config: dict | None)
         )
 
 
+def register_graph_sync(
+    graph_id: str, graph: GraphValue, config: dict | None = None
+) -> None:
+    lg_asyncio.run_coroutine_threadsafe(register_graph(graph_id, graph, config))
+
+
 @asynccontextmanager
 async def _generate_graph(value: Any) -> AsyncIterator[Any]:
     """Yield a graph object regardless of its type."""
@@ -187,24 +194,33 @@ async def collect_graphs_from_env(register: bool = False) -> None:
     config_per_graph = _load_graph_config_from_env() or {}
 
     if paths_str:
-        specs = [
-            (
+        specs = []
+        for key, value in json.loads(paths_str).items():
+            try:
+                path_or_module, variable = value.rsplit(":", maxsplit=1)
+            except ValueError as e:
+                raise ValueError(
+                    f"Invalid path '{value}' for graph '{key}'."
+                    " Did you miss a variable name?\n"
+                    " Expected one of the following formats:"
+                    " 'my.module:variable_name' or '/path/to/file.py:variable_name'"
+                ) from e
+            specs.append(
                 GraphSpec(
                     key,
-                    module=value.split(":")[0],
-                    variable=value.split(":")[1],
+                    module=path_or_module,
+                    variable=variable,
                     config=config_per_graph.get(key),
                 )
                 if "/" not in value
                 else GraphSpec(
                     key,
-                    path=value.split(":")[0],
-                    variable=value.split(":")[1],
+                    path=path_or_module,
+                    variable=variable,
                     config=config_per_graph.get(key),
                 )
             )
-            for key, value in json.loads(paths_str).items()
-        ]
+
     else:
         specs = [
             GraphSpec(

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/lifespan.py

@@ -1,10 +1,11 @@
 import asyncio
 from contextlib import asynccontextmanager
 
+import structlog
 from starlette.applications import Starlette
 
 import langgraph_api.config as config
-from langgraph_api.asyncio import SimpleTaskGroup
+from langgraph_api.asyncio import SimpleTaskGroup, set_event_loop
 from langgraph_api.cron_scheduler import cron_scheduler
 from langgraph_api.graph import collect_graphs_from_env, stop_remote_graphs
 from langgraph_api.http import start_http_client, stop_http_client
@@ -14,6 +15,8 @@ from langgraph_storage.database import start_pool, stop_pool
 from langgraph_storage.queue import queue
 from langgraph_storage.store import Store
 
+logger = structlog.stdlib.get_logger(__name__)
+
 
 @asynccontextmanager
 async def lifespan(
@@ -21,6 +24,12 @@ async def lifespan(
     with_cron_scheduler: bool = True,
     taskset: set[asyncio.Task] | None = None,
 ):
+    try:
+        current_loop = asyncio.get_running_loop()
+        set_event_loop(current_loop)
+    except RuntimeError:
+        await logger.aerror("Failed to set loop")
+
     if not await get_license_status():
         raise ValueError(
             "License verification failed. Please ensure proper configuration:\n"

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/logging.py

@@ -119,13 +119,14 @@ class Formatter(structlog.stdlib.ProcessorFormatter):
 
 # configure structlog
 
-structlog.configure(
-    processors=[
-        structlog.stdlib.filter_by_level,
-        *shared_processors,
-        structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
-    ],
-    logger_factory=structlog.stdlib.LoggerFactory(),
-    wrapper_class=structlog.stdlib.BoundLogger,
-    cache_logger_on_first_use=True,
-)
+if not structlog.is_configured():
+    structlog.configure(
+        processors=[
+            structlog.stdlib.filter_by_level,
+            *shared_processors,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/metadata.py

@@ -28,6 +28,7 @@ elif os.getenv("LANGSMITH_HOST_PROJECT_ID"):
 else:
     HOST = "self-hosted"
 PLAN = "enterprise" if plus_features_enabled() else "developer"
+USER_API_URL = os.getenv("LANGGRAPH_API_URL", None)
 
 LOGS: list[dict] = []
 RUN_COUNTER = 0

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/models/run.py

@@ -241,7 +241,17 @@ async def create_valid_run(
     # handle multitask strategy
     inflight_runs = [run async for run in run_]
     if first["run_id"] == run_id:
-        logger.info("Created run", run_id=str(run_id), thread_id=str(thread_id))
+        logger.info(
+            "Created run",
+            run_id=str(run_id),
+            thread_id=str(thread_id),
+            assistant_id=str(assistant_id),
+            multitask_strategy=multitask_strategy,
+            stream_mode=stream_mode,
+            temporary=temporary,
+            after_seconds=payload.get("after_seconds", 0),
+            if_not_exists=payload.get("if_not_exists", "reject"),
+        )
         # inserted, proceed
         if multitask_strategy in ("interrupt", "rollback") and inflight_runs:
             try:

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/stream.py

@@ -26,7 +26,7 @@ from langgraph_api.asyncio import ValueEvent, wait_if_not_done
 from langgraph_api.command import map_cmd
 from langgraph_api.graph import get_graph
 from langgraph_api.js.base import BaseRemotePregel
-from langgraph_api.metadata import HOST, PLAN, incr_nodes
+from langgraph_api.metadata import HOST, PLAN, USER_API_URL, incr_nodes
 from langgraph_api.schema import Run, StreamMode
 from langgraph_api.serde import json_dumpb
 from langgraph_api.utils import AsyncConnectionProto
@@ -114,6 +114,7 @@ async def astream_state(
     config["metadata"]["langgraph_version"] = langgraph.version.__version__
     config["metadata"]["langgraph_plan"] = PLAN
     config["metadata"]["langgraph_host"] = HOST
+    config["metadata"]["langgraph_api_url"] = USER_API_URL
     # attach node counter
     if not isinstance(graph, BaseRemotePregel):
         config["configurable"]["__pregel_node_finished"] = incr_nodes

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/langgraph_api/worker.py

@@ -210,7 +210,7 @@ async def worker(
             status = "retry"
             run_ended_at = datetime.now(UTC).isoformat()
             await logger.awarning(
-                "Background run failed, will retry",
+                f"Background run failed, will retry. Exception: {e}",
                 exc_info=True,
                 run_id=str(run_id),
                 run_attempt=attempt,
@@ -226,7 +226,7 @@ async def worker(
             status = "error"
             run_ended_at = datetime.now(UTC).isoformat()
             await logger.aexception(
-                "Background run failed",
+                f"Background run failed. Exception: {exc}",
                 exc_info=not isinstance(exc, RemoteException),
                 run_id=str(run_id),
                 run_attempt=attempt,

{langgraph_api-0.0.32 → langgraph_api-0.0.33}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-api"
-version = "0.0.32"
+version = "0.0.33"
 description = ""
 authors = [
     "Nuno Campos <nuno@langchain.dev>",