langgraph-api 0.1.4__tar.gz → 0.1.6__tar.gz

{langgraph_api-0.1.4 → langgraph_api-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langgraph-api
-Version: 0.1.4
+Version: 0.1.6
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos

langgraph_api-0.1.6/langgraph_api/__init__.py

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

{langgraph_api-0.1.4 → langgraph_api-0.1.6}/langgraph_api/api/__init__.py

@@ -20,6 +20,7 @@ from langgraph_api.api.ui import ui_routes
 from langgraph_api.auth.middleware import auth_middleware
 from langgraph_api.config import HTTP_CONFIG, MIGRATIONS_PATH
 from langgraph_api.graph import js_bg_tasks
+from langgraph_api.js.base import is_js_path
 from langgraph_api.validation import DOCS_HTML
 from langgraph_runtime.database import connect, healthcheck
 
@@ -89,6 +90,12 @@ def load_custom_app(app_import: str) -> Starlette | None:
     # Expect a string in either "path/to/file.py:my_variable" or "some.module.in:my_variable"
     logger.info(f"Loading custom app from {app_import}")
     path, name = app_import.rsplit(":", 1)
+
+    # skip loading custom app if it's a js path
+    # we are handling this in `langgraph_api.js.remote.JSCustomHTTPProxyMiddleware`
+    if is_js_path(path):
+        return None
+
     try:
         os.environ["__LANGGRAPH_DEFER_LOOPBACK_TRANSPORT"] = "true"
         if os.path.isfile(path) or path.endswith(".py"):

{langgraph_api-0.1.4 → langgraph_api-0.1.6}/langgraph_api/auth/langsmith/backend.py

@@ -32,6 +32,7 @@ class LangsmithAuthBackend(AuthenticationBackend):
             ("X-Tenant-Id", conn.headers.get("x-tenant-id")),
             ("X-Api-Key", conn.headers.get("x-api-key")),
             ("X-Service-Key", conn.headers.get("x-service-key")),
+            ("Cookie", conn.headers.get("cookie")),
         ]
         if not any(h[1] for h in headers):
             raise AuthenticationError("Missing authentication headers")

{langgraph_api-0.1.4 → langgraph_api-0.1.6}/langgraph_api/cli.py

@@ -136,6 +136,7 @@ def run_server(
     disable_persistence: bool = False,
     allow_blocking: bool = False,
     runtime_edition: Literal["inmem", "community", "postgres"] = "inmem",
+    server_level: str = "WARNING",
     **kwargs: typing.Any,
 ):
     """Run the LangGraph API server."""
@@ -149,8 +150,10 @@ def run_server(
 
     env_vars = env if isinstance(env, Mapping) else None
     mount_prefix = None
-    if http:
+    if http is not None and http.get("mount_prefix") is not None:
         mount_prefix = http.get("mount_prefix")
+    if os.environ.get("LANGGRAPH_MOUNT_PREFIX"):
+        mount_prefix = os.environ.get("LANGGRAPH_MOUNT_PREFIX")
     if isinstance(env, str | pathlib.Path):
         try:
             from dotenv.main import DotEnv
@@ -289,7 +292,7 @@ For production use, please use LangGraph Cloud.
             for k, v in kwargs.items()
             if k in inspect.signature(uvicorn.run).parameters
         }
-
+        server_level = server_level.upper()
         uvicorn.run(
             "langgraph_api.server:app",
             host=host,
@@ -315,6 +318,11 @@ For production use, please use LangGraph Cloud.
                         "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,

{langgraph_api-0.1.4 → langgraph_api-0.1.6}/langgraph_api/graph.py

@@ -289,6 +289,7 @@ async def collect_graphs_from_env(register: bool = False) -> None:
 
         from langgraph_api.js.remote import (
             RemotePregel,
+            run_js_http_process,
             run_js_process,
             run_remote_checkpointer,
             wait_until_js_ready,
@@ -306,6 +307,22 @@ async def collect_graphs_from_env(register: bool = False) -> None:
                 name="remote-graphs",
             )
         )
+
+        if (
+            config.HTTP_CONFIG
+            and config.HTTP_CONFIG.get("app")
+            and is_js_path(config.HTTP_CONFIG.get("app").split(":")[0])
+        ):
+            js_bg_tasks.add(
+                asyncio.create_task(
+                    run_js_http_process(
+                        paths_str,
+                        config.HTTP_CONFIG.get("app"),
+                        watch="--reload" in sys.argv[1:],
+                    ),
+                )
+            )
+
         for task in js_bg_tasks:
             task.add_done_callback(_handle_exception)
 

langgraph_api-0.1.6/langgraph_api/js/.prettierrc

@@ -0,0 +1,3 @@
+{
+  "semi": true
+}

langgraph_api-0.1.6/langgraph_api/js/client.http.mts

@@ -0,0 +1,142 @@
+/// <reference types="./global.d.ts" />
+
+import type { Hono } from "hono";
+import { serve } from "@hono/node-server";
+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";
+
+const logger = createLogger({
+  level: "debug",
+  format: format.combine(
+    format.errors({ stack: true }),
+    format.timestamp(),
+    format.json(),
+    format.printf((info) => {
+      const { timestamp, level, message, ...rest } = info;
+
+      let event;
+      if (typeof message === "string") {
+        event = message;
+      } else {
+        event = JSON.stringify(message);
+      }
+
+      if (rest.stack) {
+        rest.message = event;
+        event = rest.stack;
+      }
+
+      return JSON.stringify({ timestamp, level, event, ...rest });
+    }),
+  ),
+  transports: [
+    new transports.Console({
+      handleExceptions: true,
+      handleRejections: true,
+    }),
+  ],
+});
+
+const HTTP_PORT = 5557;
+
+const wrapHonoApp = (app: Hono) => {
+  // We do this to avoid importing Hono from server dependencies
+  // b/c the user's Hono version might be different than ours.
+  // See warning here: https://hono.dev/docs/guides/middleware#built-in-middleware
+  const newApp = new (Object.getPrototypeOf(app).constructor)() as Hono<{
+    Variables: { body: string | ArrayBuffer | ReadableStream | null };
+  }>;
+
+  // This endpoint is used to check if we can yield the routing to the Python server early.
+  // Note: will always yield if user added a custom middleware, as in that case
+  // the router will always find a suitable handler.
+  newApp.options("/__langgraph_check", (c) => {
+    const method = c.req.header("x-langgraph-method");
+    const path = c.req.header("x-langgraph-path");
+    if (!method || !path) return c.body(null, 400);
+
+    const [handlers] = app.router.match(method, path);
+    if (handlers.length === 0) return c.body(null, 404);
+    return c.body(null, 200);
+  });
+
+  newApp.route("/", app);
+
+  // `notFound` handler is overriden here to yield back to the Python server
+  // alongside any accumulated headers from middlewares.
+  // TODO: figure out how to compose the user-land `notFound` handler.
+  newApp.notFound(async (c) => {
+    // send the request body back to the Python server
+    // Use the cached body in-case the user mutated the body
+    let payload: any = null;
+    try {
+      payload = JSON.stringify(await c.req.json()) ?? null;
+    } catch {
+      // pass
+    }
+
+    return c.body(payload, {
+      status: 404,
+      // This header is set to denote user-land 404s vs internal 404s.
+      headers: {
+        "x-langgraph-status": "not-found",
+        "x-langgraph-body": payload != null ? "true" : "false",
+      },
+    });
+  });
+
+  return newApp;
+};
+
+async function registerHttp(appPath: string, options: { cwd: string }) {
+  const [userFile, exportSymbol] = appPath.split(":", 2);
+  const sourceFile = path.resolve(options.cwd, userFile);
+
+  const user = (await import(url.pathToFileURL(sourceFile).toString()).then(
+    (module) => module[exportSymbol || "default"],
+  )) as Hono | undefined;
+
+  if (!user) throw new Error(`Failed to load HTTP app: ${appPath}`);
+  return wrapHonoApp(user);
+}
+
+async function main() {
+  const http = z
+    .object({
+      app: z.string().optional(),
+      disable_assistants: z.boolean().default(false),
+      disable_threads: z.boolean().default(false),
+      disable_runs: z.boolean().default(false),
+      disable_store: z.boolean().default(false),
+      disable_meta: z.boolean().default(false),
+      cors: z
+        .object({
+          allow_origins: z.array(z.string()).optional(),
+          allow_methods: z.array(z.string()).optional(),
+          allow_headers: z.array(z.string()).optional(),
+          allow_credentials: z.boolean().optional(),
+          allow_origin_regex: z.string().optional(),
+          expose_headers: z.array(z.string()).optional(),
+          max_age: z.number().optional(),
+        })
+        .optional(),
+    })
+    .parse(JSON.parse(process.env.LANGGRAPH_HTTP ?? "{}"));
+
+  if (!http.app) throw new Error("No HTTP app path provided");
+  const app = await registerHttp(http.app, { cwd: process.cwd() });
+
+  serve({ fetch: app.fetch, hostname: "localhost", port: HTTP_PORT }, (c) =>
+    logger.info(`Listening to ${c.address}:${c.port}`),
+  );
+}
+
+process.on("uncaughtExceptionMonitor", (error) => {
+  logger.error(error);
+  gracefulExit();
+});
+
+main();

{langgraph_api-0.1.4 → langgraph_api-0.1.6}/langgraph_api/js/remote.py

@@ -3,7 +3,8 @@ import logging
 import os
 import shutil
 import ssl
-from collections.abc import AsyncIterator
+from collections import deque
+from collections.abc import AsyncIterator, Callable
 from contextlib import AbstractContextManager
 from typing import Any, Literal, Self, cast
 
@@ -26,12 +27,14 @@ from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
 from langgraph.types import Command, Interrupt, Send
 from langgraph_sdk import Auth
 from pydantic import BaseModel
+from starlette import types
 from starlette.applications import Starlette
 from starlette.authentication import (
     AuthCredentials,
     AuthenticationBackend,
     BaseUser,
 )
+from starlette.datastructures import MutableHeaders
 from starlette.exceptions import HTTPException
 from starlette.requests import HTTPConnection, Request
 from starlette.routing import Route
@@ -48,8 +51,9 @@ from langgraph_api.utils import AsyncConnectionProto
 
 logger = structlog.stdlib.get_logger(__name__)
 
-GRAPH_PORT = 5556
 REMOTE_PORT = 5555
+GRAPH_PORT = 5556
+GRAPH_HTTP_PORT = 5557
 SSL = ssl.create_default_context(cafile=certifi.where())
 
 if port := int(os.getenv("PORT", "8080")):
@@ -336,7 +340,9 @@ async def run_js_process(paths_str: str, watch: bool = False):
     # check if tsx is available
     tsx_path = shutil.which("tsx")
     if tsx_path is None:
-        raise FileNotFoundError("tsx not found in PATH")
+        raise FileNotFoundError(
+            "tsx not found in PATH. Please upgrade to latest LangGraph CLI to support running JS graphs."
+        )
     attempt = 0
     while not asyncio.current_task().cancelled():
         client_file = os.path.join(os.path.dirname(__file__), "client.mts")
@@ -372,6 +378,54 @@ async def run_js_process(paths_str: str, watch: bool = False):
                 attempt += 1
 
 
+async def run_js_http_process(paths_str: str, http_config: dict, watch: bool = False):
+    # check if tsx is available
+    tsx_path = shutil.which("tsx")
+    if tsx_path is None:
+        raise FileNotFoundError(
+            "tsx not found in PATH. Please upgrade to latest LangGraph CLI to support running JS graphs."
+        )
+
+    attempt = 0
+    while not asyncio.current_task().cancelled():
+        client_file = os.path.join(os.path.dirname(__file__), "client.http.mts")
+        args = ("tsx", "watch", client_file) if watch else ("tsx", client_file)
+        pid = None
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *args,
+                env={
+                    "LANGGRAPH_HTTP": orjson.dumps(http_config),
+                    "LANGSERVE_GRAPHS": paths_str,
+                    "LANGCHAIN_CALLBACKS_BACKGROUND": "true",
+                    "NODE_ENV": "development" if watch else "production",
+                    "CHOKIDAR_USEPOLLING": "true",
+                    **os.environ,
+                },
+            )
+
+            pid = process.pid
+            logger.info("Started JS HTTP process [%d]", pid)
+
+            code = await process.wait()
+            raise Exception(f"JS HTTP process exited with code {code}")
+
+        except asyncio.CancelledError:
+            logger.info("Shutting down JS HTTP process [%d]", pid or -1)
+            try:
+                process.terminate()
+                await process.wait()
+            except (UnboundLocalError, ProcessLookupError):
+                pass
+            raise
+        except Exception:
+            if attempt >= 3:
+                raise
+            else:
+                logger.warning(f"Retrying JS HTTP process {3 - attempt} more times...")
+                attempt += 1
+
+
 def _get_passthrough_checkpointer(conn: AsyncConnectionProto):
     from langgraph_runtime.checkpoint import Checkpointer
 
@@ -668,8 +722,8 @@ class DisableHttpxLoggingContextManager(AbstractContextManager):
 
     filter: logging.Filter
 
-    def filter(self, record: logging.LogRecord) -> bool:
-        return "200 OK" not in record.getMessage()
+    def __init__(self, filter: Callable[[logging.LogRecord], bool] | None = None):
+        self.filter = filter or (lambda record: "200 OK" not in record.getMessage())
 
     def __enter__(self):
         logging.getLogger("httpx").addFilter(self.filter)
@@ -820,3 +874,139 @@ async def handle_js_auth_event(
             value["metadata"].update(metadata)
 
     return filters
+
+
+class JSCustomHTTPProxyMiddleware:
+    def __init__(self, app: types.ASGIApp) -> None:
+        self.app = app
+        self.proxy_client = httpx.AsyncClient(
+            base_url=f"http://localhost:{GRAPH_HTTP_PORT}",
+            timeout=httpx.Timeout(None),
+            limits=httpx.Limits(),
+            transport=httpx.AsyncHTTPTransport(verify=SSL),
+        )
+
+    async def __call__(
+        self, scope: types.Scope, receive: types.Receive, send: types.Send
+    ) -> None:
+        if scope["type"] != "http" or "__langgraph_check" in scope["path"]:
+            # TODO: add support for proxying `websockets``
+            await self.app(scope, receive, send)
+            return
+
+        # First, check if the request can be handled by the JS server
+        with DisableHttpxLoggingContextManager(
+            filter=lambda record: "__langgraph_check" not in record.getMessage()
+        ):
+            res = await self.proxy_client.options(
+                "/__langgraph_check",
+                headers={
+                    "x-langgraph-method": scope["method"],
+                    "x-langgraph-path": scope["path"],
+                },
+            )
+
+        input_buffer: deque[types.Message] = deque()
+
+        async def yield_to_python(node_request: httpx.Response):
+            nonlocal input_buffer
+
+            async def replay_request():
+                if input_buffer:
+                    if node_request.headers.get("x-langgraph-body") == "true":
+                        input_buffer.clear()
+                        return {
+                            "type": "http.request",
+                            "body": await node_request.aread(),
+                            "more_body": False,
+                        }
+
+                    return input_buffer.popleft()
+                else:
+                    return await receive()
+
+            async def send_with_extra_headers(message: types.Message):
+                if message["type"] == "http.response.start":
+                    headers = MutableHeaders(scope=message)
+                    for k, v in node_request.headers.items():
+                        if k in (
+                            "content-length",
+                            "content-encoding",
+                            "content-type",
+                            "transfer-encoding",
+                            "connection",
+                            "keep-alive",
+                            "x-langgraph-body",
+                            "x-langgraph-status",
+                        ):
+                            continue
+
+                        # Respect existing headers set by the Python server
+                        headers.append(k, headers.get(k, None) or v)
+
+                await send(message)
+
+            return await self.app(scope, replay_request, send_with_extra_headers)
+
+        # If the JS server does not handle the request, yield the control back to the
+        # Python server.
+        if not res.is_success:
+            return await yield_to_python(res)
+
+        # Stream request body
+        async def upload_request_body() -> AsyncIterator[bytes]:
+            nonlocal input_buffer
+
+            more_body = True
+            while more_body:
+                message = await receive()
+                input_buffer.append(message)
+
+                more_body = message.get("more_body", False)
+                yield message.get("body", b"")
+
+        # Make the proxied request
+        async with self.proxy_client.stream(
+            scope["method"],
+            scope["path"],
+            params=scope["query_string"],
+            headers={
+                k.decode("latin-1"): v.decode("latin-1")
+                for k, v in scope["headers"]
+                if k.lower() not in (b"host", b"content-length")
+            },
+            content=upload_request_body(),
+        ) as response:
+            if (
+                response.status_code == 404
+                and response.headers.get("x-langgraph-status") == "not-found"
+            ):
+                return await yield_to_python(response)
+
+            # Send the response headers
+            await send(
+                {
+                    "type": "http.response.start",
+                    "status": response.status_code,
+                    "headers": [
+                        (k.encode("latin-1"), v.encode("latin-1"))
+                        for k, v in response.headers.items()
+                        if k.lower() not in (b"transfer-encoding",)
+                    ],
+                }
+            )
+
+            # Stream the response body
+            async for chunk in response.aiter_raw():
+                await send(
+                    {"type": "http.response.body", "body": chunk, "more_body": True}
+                )
+
+            # Send the final empty chunk to indicate the end of the response
+            await send({"type": "http.response.body", "body": b"", "more_body": False})
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.proxy_client.aclose()