langgraph-api 0.1.9__tar.gz → 0.1.12__tar.gz

{langgraph_api-0.1.9 → langgraph_api-0.1.12}/PKG-INFO

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

langgraph_api-0.1.12/langgraph_api/__init__.py

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

{langgraph_api-0.1.9 → langgraph_api-0.1.12}/langgraph_api/cli.py

@@ -122,6 +122,7 @@ def run_server(
     n_jobs_per_worker: int | None = None,
     env_file: str | None = None,
     open_browser: bool = False,
+    tunnel: bool = False,
     debug_port: int | None = None,
     wait_for_client: bool = False,
     env: str | pathlib.Path | Mapping[str, str] | None = None,
@@ -189,9 +190,33 @@ def run_server(
             debugpy.wait_for_client()
             logger.info("Debugger attached. Starting server...")
 
-    local_url = f"http://{host}:{port}"
+    # Determine local or tunneled URL
+    upstream_url = f"http://{host}:{port}"
     if mount_prefix:
-        local_url += mount_prefix
+        upstream_url += mount_prefix
+    if tunnel:
+        logger.info("Starting Cloudflare Tunnel...")
+        from concurrent.futures import TimeoutError as FutureTimeoutError
+
+        from langgraph_api.tunneling.cloudflare import start_tunnel
+
+        tunnel_obj = start_tunnel(port)
+        try:
+            public_url = tunnel_obj.url.result(timeout=30)
+        except FutureTimeoutError:
+            logger.warning(
+                "Timed out waiting for Cloudflare Tunnel URL; using local URL %s",
+                upstream_url,
+            )
+            public_url = upstream_url
+        except Exception as e:
+            tunnel_obj.process.kill()
+            raise RuntimeError("Failed to start Cloudflare Tunnel") from e
+        local_url = public_url
+        if mount_prefix:
+            local_url += mount_prefix
+    else:
+        local_url = upstream_url
     to_patch = dict(
         MIGRATIONS_PATH="__inmem",
         DATABASE_URI=":memory:",
@@ -361,6 +386,11 @@ def main():
         action="store_true",
         help="Whether to break and wait for a debugger to attach",
     )
+    parser.add_argument(
+        "--tunnel",
+        action="store_true",
+        help="Expose the server via Cloudflare Tunnel",
+    )
 
     args = parser.parse_args()
 
@@ -378,6 +408,7 @@ def main():
         graphs,
         n_jobs_per_worker=args.n_jobs_per_worker,
         open_browser=not args.no_browser,
+        tunnel=args.tunnel,
         debug_port=args.debug_port,
         wait_for_client=args.wait_for_client,
         env=config_data.get("env", None),

{langgraph_api-0.1.9 → langgraph_api-0.1.12}/langgraph_api/js/package.json

@@ -10,7 +10,7 @@
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
     "@langchain/core": "^0.3.44",
-    "@langchain/langgraph": "^0.2.64",
+    "@langchain/langgraph": "^0.2.65",
     "@langchain/langgraph-checkpoint": "^0.0.17",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",

{langgraph_api-0.1.9 → langgraph_api-0.1.12}/langgraph_api/js/tests/api.test.mts

@@ -2078,6 +2078,7 @@ it("custom routes - mutate request body", async () => {
     messages: expect.arrayContaining([
       expect.objectContaining({ content: "end: extra-client" }),
     ]),
+    prompts: [],
   });
 });
 
@@ -2094,6 +2095,34 @@ it("custom routes - langgraph", async () => {
       messages: expect.arrayContaining([
         expect.objectContaining({ content: "input" }),
       ]),
+      prompts: [],
+    },
+  });
+});
+
+it("send map-reduce", async () => {
+  const assistant = await client.assistants.create({ graphId: "agent_simple" });
+  const thread = await client.threads.create();
+
+  const chunks = await gatherIterator(
+    client.runs.stream(thread.thread_id, assistant.assistant_id, {
+      input: { messages: [{ role: "human", content: "input" }] },
+      config: { configurable: { "map-reduce": true } },
+    }),
+  );
+
+  expect(chunks.filter((i) => i.event === "error")).toEqual([]);
+  expect(findLast(chunks, (i) => i.event === "values")).toMatchObject({
+    data: {
+      messages: [
+        { type: "human", content: "input" },
+        { type: "human", content: "map-reduce" },
+      ],
+      prompts: [
+        { type: "ai", content: "first" },
+        { type: "ai", content: "second" },
+        { type: "ai", content: "third" },
+      ],
     },
   });
 });

{langgraph_api-0.1.9 → langgraph_api-0.1.12}/langgraph_api/js/tests/graphs/agent_simple.mts

@@ -7,7 +7,7 @@ import {
   START,
   LangGraphRunnableConfig,
 } from "@langchain/langgraph";
-import { BaseMessage, ToolMessage } from "@langchain/core/messages";
+import { AIMessage, BaseMessage, ToolMessage } from "@langchain/core/messages";
 import { FakeListChatModel } from "@langchain/core/utils/testing";
 
 const getStableModel = (() => {
@@ -25,6 +25,7 @@ const AgentState = Annotation.Root({
   key_two: Annotation<string>(),
   sleep: Annotation<number>(),
   messages: MessagesAnnotation.spec.messages,
+  prompts: MessagesAnnotation.spec.messages,
 });
 
 async function callModel(
@@ -47,6 +48,10 @@ async function callModel(
     };
   }
 
+  if (config.configurable?.["map-reduce"] != null) {
+    return { messages: ["map-reduce"] };
+  }
+
   const model = getStableModel(config.configurable?.thread_id ?? "$");
   const existing = await config.store?.get([userId ?? "ALL"], "key_one");
   if (!existing) {
@@ -68,15 +73,31 @@ async function callTool(
   return { messages: [response] };
 }
 
-function shouldContinue(state: typeof AgentState.State): typeof END | Send {
+function shouldContinue(
+  state: typeof AgentState.State,
+): typeof END | Send | Send[] {
   const lastMessage = state.messages.at(-1);
   if ((lastMessage?.content as string).startsWith("end")) return END;
+  if ((lastMessage?.content as string).includes("map-reduce")) {
+    return [
+      new Send("map-reduce", { messages: [new AIMessage("first")] }),
+      new Send("map-reduce", { messages: [new AIMessage("second")] }),
+      new Send("map-reduce", { messages: [new AIMessage("third")] }),
+    ];
+  }
   return new Send("tool", lastMessage);
 }
 
+function callMapReduce(state: {
+  messages: BaseMessage[];
+}): typeof AgentState.Update {
+  return { prompts: state.messages.slice(-1) };
+}
+
 const workflow = new StateGraph(AgentState)
   .addNode("agent", callModel)
   .addNode("tool", callTool)
+  .addNode("map-reduce", callMapReduce)
   .addEdge(START, "agent")
   .addConditionalEdges("agent", shouldContinue)
   .addEdge("tool", "agent");

{langgraph_api-0.1.9 → langgraph_api-0.1.12}/langgraph_api/js/yarn.lock

@@ -256,10 +256,10 @@
     esbuild-plugin-tailwindcss "^2.0.1"
     zod "^3.23.8"
 
-"@langchain/langgraph@^0.2.64":
-  version "0.2.64"
-  resolved "https://registry.yarnpkg.com/@langchain/langgraph/-/langgraph-0.2.64.tgz#90f8c32bc34fbc3f7c1b04595f1e5165dd5a5fb4"
-  integrity sha512-M6lh8ekDoZVCLdA10jeqIsU58LODDzXpP38aeXil5A5pg31IJp5L8O4yBfbp8mRobVX+Bbga5R5ZRyQBQl6NTg==
+"@langchain/langgraph@^0.2.65":
+  version "0.2.65"
+  resolved "https://registry.yarnpkg.com/@langchain/langgraph/-/langgraph-0.2.65.tgz#f080add1c26a3eb3744af2ef23b8b53eddbf5cb2"
+  integrity sha512-g/Xap2KSEaEBXMJXGZTh31fd0qrdfaWA1l8NJzweJg6AkvVSf+d6DmMk9DtzGW8W1H1qQ2I6FWZ3AdP61Kkaig==
   dependencies:
     "@langchain/langgraph-checkpoint" "~0.0.17"
     "@langchain/langgraph-sdk" "~0.0.32"

{langgraph_api-0.1.9 → langgraph_api-0.1.12}/langgraph_api/metadata.py

@@ -40,7 +40,10 @@ RUN_COUNTER = 0
 NODE_COUNTER = 0
 FROM_TIMESTAMP = datetime.now(UTC).isoformat()
 
-if "api.smith.langchain.com" in LANGSMITH_AUTH_ENDPOINT:
+if (
+    "api.smith.langchain.com" in LANGSMITH_AUTH_ENDPOINT
+    and not LANGGRAPH_CLOUD_LICENSE_KEY
+):
     METADATA_ENDPOINT = LANGSMITH_AUTH_ENDPOINT.rstrip("/") + "/v1/metadata/submit"
 else:
     METADATA_ENDPOINT = "https://api.smith.langchain.com/v1/metadata/submit"
@@ -100,20 +103,21 @@ async def metadata_loop() -> None:
             "from_timestamp": from_timestamp,
             "to_timestamp": to_timestamp,
             "tags": {
+                # Tag values must be strings.
                 "langgraph.python.version": langgraph.version.__version__,
-                "langgraph_api.version": __version__,
-                "langgraph.platform.revision": REVISION,
-                "langgraph.platform.variant": VARIANT,
+                "langgraph_api.version": __version__ or "",
+                "langgraph.platform.revision": REVISION or "",
+                "langgraph.platform.variant": VARIANT or "",
                 "langgraph.platform.host": HOST,
-                "langgraph.platform.tenant_id": TENANT_ID,
-                "langgraph.platform.project_id": PROJECT_ID,
+                "langgraph.platform.tenant_id": TENANT_ID or "",
+                "langgraph.platform.project_id": PROJECT_ID or "",
                 "langgraph.platform.plan": PLAN,
                 # user app features
-                "user_app.uses_indexing": USES_INDEXING,
-                "user_app.uses_custom_app": USES_CUSTOM_APP,
-                "user_app.uses_custom_auth": USES_CUSTOM_AUTH,
-                "user_app.uses_thread_ttl": USES_THREAD_TTL,
-                "user_app.uses_store_ttl": USES_STORE_TTL,
+                "user_app.uses_indexing": str(USES_INDEXING or ""),
+                "user_app.uses_custom_app": str(USES_CUSTOM_APP or ""),
+                "user_app.uses_custom_auth": str(USES_CUSTOM_AUTH),
+                "user_app.uses_thread_ttl": str(USES_THREAD_TTL),
+                "user_app.uses_store_ttl": str(USES_STORE_TTL),
             },
             "measures": {
                 "langgraph.platform.runs": runs,

{langgraph_api-0.1.9 → langgraph_api-0.1.12}/langgraph_api/server.py

@@ -30,7 +30,6 @@ from langgraph_runtime.lifespan import lifespan
 from langgraph_api.middleware.http_logger import AccessLoggerMiddleware
 from langgraph_api.middleware.private_network import PrivateNetworkMiddleware
 from langgraph_api.utils import SchemaGenerator
-from langgraph_license.middleware import LicenseValidationMiddleware
 from langgraph_runtime.retry import OVERLOADED_EXCEPTIONS
 from langgraph_api.js.base import is_js_path
 from langgraph_sdk.client import configure_loopback_transports
@@ -68,7 +67,6 @@ middleware.extend(
                 **config.CORS_CONFIG,
             )
         ),
-        Middleware(LicenseValidationMiddleware),
         Middleware(AccessLoggerMiddleware, logger=logger),
     ]
 )

langgraph_api-0.1.12/langgraph_api/tunneling/cloudflare.py

@@ -0,0 +1,119 @@
+import atexit
+import logging
+import os
+import platform as _platform
+import re
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import threading
+import urllib.request
+from concurrent.futures import Future
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+CLOUDFLARED_VERSION = os.environ.get("LANGGRAPH_CLOUDFLARED_VERSION", "2025.2.1")
+CACHE_DIR = (
+    Path(os.path.expanduser("~"))
+    / ".langgraph_api"
+    / "cloudflared"
+    / CLOUDFLARED_VERSION
+)
+
+
+def get_platform_arch():
+    plat = sys.platform
+    if plat.startswith("darwin"):
+        plat = "darwin"
+    elif plat.startswith("linux"):
+        plat = "linux"
+    elif plat.startswith("win"):
+        plat = "windows"
+    else:
+        raise RuntimeError(f"Unsupported platform: {sys.platform}")
+    arch = _platform.machine().lower()
+    if arch in ("x86_64", "amd64"):
+        arch = "amd64"
+    elif arch in ("arm64", "aarch64"):
+        arch = "arm64"
+    elif arch in ("i386", "i686", "x86"):
+        arch = "386"
+    else:
+        raise RuntimeError(f"Unsupported architecture: {_platform.machine()}")
+    return plat, arch
+
+
+def ensure_cloudflared() -> Path:
+    plat, arch = get_platform_arch()
+    # determine file names and if archive
+    if plat == "windows":
+        file_name = f"cloudflared-windows-{arch}.exe"
+        is_archive = False
+    elif plat == "darwin":
+        file_name = f"cloudflared-darwin-{arch}.tgz"
+        is_archive = True
+    else:  # linux
+        file_name = f"cloudflared-linux-{arch}"
+        is_archive = False
+
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    binary_name = "cloudflared" if is_archive else file_name
+    target_bin = CACHE_DIR / binary_name
+    if not target_bin.exists():
+        url = f"https://github.com/cloudflare/cloudflared/releases/download/{CLOUDFLARED_VERSION}/{file_name}"
+        logger.info(f"Downloading cloudflared from {url}")
+        with urllib.request.urlopen(url) as resp:
+            data = resp.read()
+        with tempfile.TemporaryDirectory() as tmpd:
+            tmpd = Path(tmpd)
+            path = tmpd / file_name
+            path.write_bytes(data)
+            if is_archive:
+                with tarfile.open(path) as tf:
+                    tf.extractall(tmpd)
+                src = tmpd / "cloudflared"
+            else:
+                src = path
+            shutil.move(str(src), str(target_bin))
+        target_bin.chmod(0o755)
+    return target_bin
+
+
+class CloudflareTunnel:
+    def __init__(self, process: subprocess.Popen, url_future: Future[str]):
+        self.process = process
+        self.url = url_future
+
+
+def start_tunnel(port: int) -> CloudflareTunnel:
+    bin_path = ensure_cloudflared()
+    cmd = [str(bin_path), "tunnel", "--url", f"http://localhost:{port}"]
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1,
+    )
+    atexit.register(proc.kill)
+
+    url_future: Future[str] = Future()
+
+    def _reader(stream):
+        for line in stream:
+            line = line.strip()
+            logger.info(f"[cloudflared] {line}")
+            if not url_future.done():
+                # match any trycloudflare.com host with optional subdomains
+                pattern = re.compile(r"(https://[A-Za-z0-9.-]+\.trycloudflare\.com)")
+                m = pattern.search(line)
+                if m:
+                    url_future.set_result(m.group(1))
+
+    threading.Thread(target=_reader, args=(proc.stdout,), daemon=True).start()
+    threading.Thread(target=_reader, args=(proc.stderr,), daemon=True).start()
+
+    return CloudflareTunnel(proc, url_future)

langgraph_api-0.1.12/langgraph_license/validation.py

@@ -0,0 +1,22 @@
+"""Noop license middleware"""
+
+
+async def get_license_status() -> bool:
+    """Always return true"""
+    return True
+
+
+def plus_features_enabled() -> bool:
+    """Always return false"""
+    return False
+
+
+async def check_license_periodically(_: int = 60):
+    """
+    Periodically re-verify the license.
+    If the license ever fails, you could decide to log,
+    raise an exception, or attempt a graceful shutdown.
+    """
+    raise NotImplementedError(
+        "This is a noop license middleware. No license check is performed."
+    )

{langgraph_api-0.1.9 → langgraph_api-0.1.12}/pyproject.toml

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

langgraph_api-0.1.9/langgraph_api/__init__.py

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

langgraph_api-0.1.9/langgraph_license/middleware.py

@@ -1,21 +0,0 @@
-"""Middleware for license validation."""
-
-from typing import Any
-
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import Response
-from starlette.types import ASGIApp
-
-
-class LicenseValidationMiddleware(BaseHTTPMiddleware):
-    """Noop license middleware"""
-
-    def __init__(self, app: ASGIApp):
-        """Initialize middleware."""
-        super().__init__(app)
-
-    async def dispatch(self, request: Request, call_next: Any) -> Response:
-        """Noop middleware."""
-        response = await call_next(request)
-        return response

langgraph_api-0.1.9/langgraph_license/validation.py

@@ -1,11 +0,0 @@
-"""Noop license middleware"""
-
-
-async def get_license_status() -> bool:
-    """Always return true"""
-    return True
-
-
-def plus_features_enabled() -> bool:
-    """Always return false"""
-    return False