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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.8.5
+Version: 0.8.7
 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-0.8.7}/benchmark/continuous/pyproject.toml

@@ -4,8 +4,8 @@ version = "0.1.0"
 description = "Continuous stress test for Agent Server"
 requires-python = ">=3.13"
 dependencies = [
-    "langgraph-sdk>=0.2.10",
-    "click>=8.3.2",
+    "langgraph-sdk>=0.3.13",
+    "click>=8.3.3",
     "structlog>=24.1.0",
     "datadog-api-client>=2.0.0",
     "python-dateutil>=2.8.0",

langgraph_api-0.8.7/langgraph_api/__init__.py

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

{langgraph_api-0.8.5 → langgraph_api-0.8.7}/langgraph_api/api/a2a.py

@@ -552,6 +552,22 @@ def _create_interrupt_artifact(interrupts: list[dict[str, Any]]) -> dict[str, An
     }
 
 
+def _tool_result_data(it: dict[str, Any]) -> dict[str, Any] | None:
+    tool_call_id = it.get("tool_call_id")
+    if not isinstance(tool_call_id, str) or not tool_call_id:
+        return None
+
+    result: dict[str, Any] = {"toolCallId": tool_call_id}
+    content = it.get("content")
+    if content not in (None, ""):
+        result["content"] = content
+    for key in ("name", "status"):
+        value = it.get(key)
+        if isinstance(value, str) and value:
+            result[key] = value
+    return result
+
+
 def _lc_stream_items_to_a2a_message(
     items: list[dict[str, Any]],
     *,
@@ -604,6 +620,9 @@ def _lc_stream_items_to_a2a_message(
         tc = it.get("tool_calls")
         if isinstance(tc, list) and tc:
             extra_data.setdefault("tool_calls", tc)
+        tool_result = _tool_result_data(it)
+        if tool_result is not None:
+            extra_data.setdefault("tool_results", []).append(tool_result)
 
     parts: list[dict[str, Any]] = []
     if text_parts:
@@ -809,10 +828,21 @@ def _convert_messages_to_a2a_format(
                 else "ROLE_AGENT"
             )
 
+            parts: list[dict[str, Any]] = [{"kind": "text", "text": str(content)}]
+            extra_data: dict[str, Any] = {}
+            tc = msg.get("tool_calls")
+            if isinstance(tc, list) and tc:
+                extra_data["tool_calls"] = tc
+            tool_result = _tool_result_data(msg)
+            if tool_result is not None:
+                extra_data["tool_results"] = [tool_result]
+            if extra_data:
+                parts.append({"kind": "data", "data": extra_data})
+
             a2a_message = {
                 "kind": "message",
                 "role": a2a_role,
-                "parts": [{"kind": "text", "text": str(content)}],
+                "parts": parts,
                 "messageId": id,
                 "taskId": task_id,
                 "contextId": context_id,

{langgraph_api-0.8.5 → langgraph_api-0.8.7}/langgraph_api/api/meta.py

@@ -47,9 +47,13 @@ def _merge_pool_stats(local: PoolStats, remote: PoolStats) -> PoolStats:
 
 
 def _pool_stats_to_prometheus_lines(
-    stats: PoolStats, project_id: str | None, revision_id: str | None
+    stats: PoolStats,
+    project_id: str | None,
+    revision_id: str | None,
+    deployment_type: str = "",
 ) -> list[str]:
     """Format merged pool stats as Prometheus text lines (same format as langgraph_runtime.database.pool_stats)."""
+    labels = f'project_id="{project_id}", revision_id="{revision_id}", deployment_type="{deployment_type}"'
     lines = []
     if "postgres" in stats:
         pg = stats["postgres"]
@@ -57,19 +61,19 @@ def _pool_stats_to_prometheus_lines(
             [
                 "# HELP lg_api_pg_pool_max The maximum size of the postgres connection pool.",
                 "# TYPE lg_api_pg_pool_max gauge",
-                f'lg_api_pg_pool_max{{project_id="{project_id}", revision_id="{revision_id}"}} {pg.get("pool_max", 0)}',
+                f"lg_api_pg_pool_max{{{labels}}} {pg.get('pool_max', 0)}",
                 "# HELP lg_api_pg_pool_size Number of connections currently managed by the postgres connection pool (in the pool, given to clients, being prepared)",
                 "# TYPE lg_api_pg_pool_size gauge",
-                f'lg_api_pg_pool_size{{project_id="{project_id}", revision_id="{revision_id}"}} {pg.get("pool_size", 0)}',
+                f"lg_api_pg_pool_size{{{labels}}} {pg.get('pool_size', 0)}",
                 "# HELP lg_api_pg_pool_available Number of connections currently idle in the postgres connection pool",
                 "# TYPE lg_api_pg_pool_available gauge",
-                f'lg_api_pg_pool_available{{project_id="{project_id}", revision_id="{revision_id}"}} {pg.get("pool_available", 0)}',
+                f"lg_api_pg_pool_available{{{labels}}} {pg.get('pool_available', 0)}",
                 "# HELP lg_api_pg_pool_requests_queued Number of postgres connection requests queued because a postgres connection wasn't immediately available in the pool",
                 "# TYPE lg_api_pg_pool_requests_queued counter",
-                f'lg_api_pg_pool_requests_queued{{project_id="{project_id}", revision_id="{revision_id}"}} {pg.get("requests_queued", 0)}',
+                f"lg_api_pg_pool_requests_queued{{{labels}}} {pg.get('requests_queued', 0)}",
                 "# HELP lg_api_pg_pool_requests_errors Number of postgres connection requests resulting in an error (timeouts, queue full...)",
                 "# TYPE lg_api_pg_pool_requests_errors counter",
-                f'lg_api_pg_pool_requests_errors{{project_id="{project_id}", revision_id="{revision_id}"}} {pg.get("requests_errors", 0)}',
+                f"lg_api_pg_pool_requests_errors{{{labels}}} {pg.get('requests_errors', 0)}",
             ]
         )
     if "redis" in stats:
@@ -78,13 +82,13 @@ def _pool_stats_to_prometheus_lines(
             [
                 "# HELP lg_api_redis_pool_available Number of connections currently idle in the redis connection pool",
                 "# TYPE lg_api_redis_pool_available gauge",
-                f'lg_api_redis_pool_available{{project_id="{project_id}", revision_id="{revision_id}"}} {rd.get("idle_connections", 0)}',
+                f"lg_api_redis_pool_available{{{labels}}} {rd.get('idle_connections', 0)}",
                 "# HELP lg_api_redis_pool_size Number of connections currently in use in the redis connection pool",
                 "# TYPE lg_api_redis_pool_size gauge",
-                f'lg_api_redis_pool_size{{project_id="{project_id}", revision_id="{revision_id}"}} {rd.get("in_use_connections", 0)}',
+                f"lg_api_redis_pool_size{{{labels}}} {rd.get('in_use_connections', 0)}",
                 "# HELP lg_api_redis_pool_max The maximum size of the redis connection pool.",
                 "# TYPE lg_api_redis_pool_max gauge",
-                f'lg_api_redis_pool_max{{project_id="{project_id}", revision_id="{revision_id}"}} {rd.get("max_connections", 0)}',
+                f"lg_api_redis_pool_max{{{labels}}} {rd.get('max_connections', 0)}",
             ]
         )
     return lines
@@ -111,7 +115,10 @@ async def meta_pool_stats(metrics_format: str) -> PoolStats | list[str]:
     merged_pool_stats = _merge_pool_stats(local_pool_stats, grpc_pool_stats)
     if metrics_format == "prometheus":
         return _pool_stats_to_prometheus_lines(
-            merged_pool_stats, metadata.PROJECT_ID, metadata.HOST_REVISION_ID
+            merged_pool_stats,
+            metadata.PROJECT_ID,
+            metadata.HOST_REVISION_ID,
+            metadata.DEPLOYMENT_TYPE,
         )
     else:
         return merged_pool_stats
@@ -154,7 +161,10 @@ async def meta_metrics(request: ApiRequest):
     workers_available = worker_metrics["available"]
 
     http_metrics = HTTP_METRICS_COLLECTOR.get_metrics(
-        metadata.PROJECT_ID, metadata.HOST_REVISION_ID, metrics_format
+        metadata.PROJECT_ID,
+        metadata.HOST_REVISION_ID,
+        metrics_format,
+        metadata.DEPLOYMENT_TYPE,
     )
 
     merged_pool_stats = await meta_pool_stats(metrics_format)
@@ -175,23 +185,24 @@ async def meta_metrics(request: ApiRequest):
             async with connect() as conn:
                 queue_stats = await Runs.stats(conn)
 
+                labels = f'project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}", deployment_type="{metadata.DEPLOYMENT_TYPE}"'
                 metrics.extend(
                     [
                         "# HELP lg_api_num_pending_runs The number of runs currently pending.",
                         "# TYPE lg_api_num_pending_runs gauge",
-                        f'lg_api_num_pending_runs{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats["n_pending"]}',
+                        f"lg_api_num_pending_runs{{{labels}}} {queue_stats['n_pending']}",
                         "# HELP lg_api_num_running_runs The number of runs currently running.",
                         "# TYPE lg_api_num_running_runs gauge",
-                        f'lg_api_num_running_runs{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats["n_running"]}',
+                        f"lg_api_num_running_runs{{{labels}}} {queue_stats['n_running']}",
                         "# HELP lg_api_pending_runs_wait_time_max The maximum time a run has been pending, in seconds.",
                         "# TYPE lg_api_pending_runs_wait_time_max gauge",
-                        f'lg_api_pending_runs_wait_time_max{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats.get("pending_runs_wait_time_max_secs") or 0}',
+                        f"lg_api_pending_runs_wait_time_max{{{labels}}} {queue_stats.get('pending_runs_wait_time_max_secs') or 0}",
                         "# HELP lg_api_pending_runs_wait_time_med The median pending wait time across runs, in seconds.",
                         "# TYPE lg_api_pending_runs_wait_time_med gauge",
-                        f'lg_api_pending_runs_wait_time_med{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats.get("pending_runs_wait_time_med_secs") or 0}',
+                        f"lg_api_pending_runs_wait_time_med{{{labels}}} {queue_stats.get('pending_runs_wait_time_med_secs') or 0}",
                         "# HELP lg_api_pending_unblocked_runs_wait_time_max The maximum time a run has been pending excluding runs blocked by another run on the same thread, in seconds.",
                         "# TYPE lg_api_pending_unblocked_runs_wait_time_max gauge",
-                        f'lg_api_pending_unblocked_runs_wait_time_max{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats.get("pending_unblocked_runs_wait_time_max_secs") or 0}',
+                        f"lg_api_pending_unblocked_runs_wait_time_max{{{labels}}} {queue_stats.get('pending_unblocked_runs_wait_time_max_secs') or 0}",
                     ]
                 )
         except Exception as e:
@@ -200,17 +211,18 @@ async def meta_metrics(request: ApiRequest):
             )
 
         if config.N_JOBS_PER_WORKER > 0:
+            worker_labels = f'project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}", deployment_type="{metadata.DEPLOYMENT_TYPE}"'
             metrics.extend(
                 [
                     "# HELP lg_api_workers_max The maximum number of workers available.",
                     "# TYPE lg_api_workers_max gauge",
-                    f'lg_api_workers_max{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_max}',
+                    f"lg_api_workers_max{{{worker_labels}}} {workers_max}",
                     "# HELP lg_api_workers_active The number of currently active workers.",
                     "# TYPE lg_api_workers_active gauge",
-                    f'lg_api_workers_active{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_active}',
+                    f"lg_api_workers_active{{{worker_labels}}} {workers_active}",
                     "# HELP lg_api_workers_available The number of available (idle) workers.",
                     "# TYPE lg_api_workers_available gauge",
-                    f'lg_api_workers_available{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_available}',
+                    f"lg_api_workers_available{{{worker_labels}}} {workers_available}",
                 ]
             )
 

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

@@ -94,6 +94,7 @@ def _is_port_available(host: str, port: int) -> bool:
     """Check if a port is available for binding."""
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
         try:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
             s.bind((host, port))
             return True
         except OSError:
@@ -150,17 +151,11 @@ def _resolve_server_url(
 
 def _resolve_port(host: str, port: int | None) -> int:
     """Resolve the port to use for the server."""
-    if port is not None:
-        if not _is_port_available(host, port):
-            raise OSError(
-                f"Port {port} is already in use. Please specify a different port "
-                f"or omit the port argument to auto-discover an available one."
-            )
-        return port
-    if _is_port_available(host, DEFAULT_PORT):
-        return DEFAULT_PORT
+    requested = port if port is not None else DEFAULT_PORT
+    if _is_port_available(host, requested):
+        return requested
     found = _find_open_port(host)
-    logger.info(f"Default port {DEFAULT_PORT} is in use, using port {found} instead.")
+    logger.warning(f"Port {requested} is already in use, using port {found} instead.")
     return found
 
 
@@ -416,7 +411,7 @@ def main():
         "--port",
         type=int,
         default=None,
-        help="Port to bind the server to (default: 2024, auto-discovers if in use)",
+        help="Port to bind the server to (default: 2024; auto-discovers another port if the requested one is in use)",
     )
     parser.add_argument("--no-reload", action="store_true", help="Disable auto-reload")
     parser.add_argument(

{langgraph_api-0.8.5 → langgraph_api-0.8.7}/langgraph_api/http_metrics.py

@@ -84,6 +84,7 @@ class HTTPMetricsCollector:
         project_id: str | None,
         revision_id: str | None,
         format: str = "prometheus",
+        deployment_type: str = "",
     ) -> dict | list[str]:
         if format == "json":
             return {
@@ -117,7 +118,7 @@ class HTTPMetricsCollector:
 
             for (method, path, status), count in self._request_counts.items():
                 metrics.append(
-                    f'lg_api_http_requests_total{{project_id="{project_id}", revision_id="{revision_id}", method="{method}", path="{path}", status="{status}"}} {count}'
+                    f'lg_api_http_requests_total{{project_id="{project_id}", revision_id="{revision_id}", deployment_type="{deployment_type}", method="{method}", path="{path}", status="{status}"}} {count}'
                 )
 
         # Histogram metrics
@@ -135,13 +136,13 @@ class HTTPMetricsCollector:
                     acc += bucket_count
                     bucket_label = self._histogram_bucket_labels[i]
                     metrics.append(
-                        f'lg_api_http_requests_latency_seconds_bucket{{project_id="{project_id}", revision_id="{revision_id}", method="{method}", path="{path}", le="{bucket_label}"}} {acc}'
+                        f'lg_api_http_requests_latency_seconds_bucket{{project_id="{project_id}", revision_id="{revision_id}", deployment_type="{deployment_type}", method="{method}", path="{path}", le="{bucket_label}"}} {acc}'
                     )
 
                 metrics.extend(
                     [
-                        f'lg_api_http_requests_latency_seconds_sum{{project_id="{project_id}", revision_id="{revision_id}", method="{method}", path="{path}"}} {hist_data["sum"]:.6f}',
-                        f'lg_api_http_requests_latency_seconds_count{{project_id="{project_id}", revision_id="{revision_id}", method="{method}", path="{path}"}} {hist_data["count"]}',
+                        f'lg_api_http_requests_latency_seconds_sum{{project_id="{project_id}", revision_id="{revision_id}", deployment_type="{deployment_type}", method="{method}", path="{path}"}} {hist_data["sum"]:.6f}',
+                        f'lg_api_http_requests_latency_seconds_count{{project_id="{project_id}", revision_id="{revision_id}", deployment_type="{deployment_type}", method="{method}", path="{path}"}} {hist_data["count"]}',
                     ]
                 )
 

{langgraph_api-0.8.5 → langgraph_api-0.8.7}/langgraph_api/js/client.mts

@@ -30,6 +30,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { serialiseAsDict, serializeError } from "./src/utils/serde.mjs";
 import * as importMap from "./src/utils/importMap.mjs";
+import { buildExperimentReplicas } from "./src/utils/experiment-tracing.mjs";
 
 import { createLogger, format, transports } from "winston";
 
@@ -45,6 +46,8 @@ import {
 } from "./src/graph.mts";
 import { asyncExitHook, gracefulExit } from "exit-hook";
 import { awaitAllCallbacks } from "@langchain/core/callbacks/promises";
+import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
+import type { BaseCallbackHandler } from "@langchain/core/callbacks/base";
 import { StatusCode } from "hono/utils/http-status";
 import {
   authenticate,
@@ -714,6 +717,17 @@ async function* streamEventsRequest(
     config.metadata.langgraph_version = version;
   }
 
+  // Mirror the Python worker's experiment-routing setup for JS graphs. The
+  // Python `tracing_context(replicas=...)` cannot cross the sidecar boundary,
+  // so build replicas from the same reserved configurable keys and attach a
+  // LangChainTracer carrying them. The framework skips its default tracer
+  // when one with name "langchain_tracer" is already present in
+  // config.callbacks (see @langchain/core callbacks/manager.js).
+  const replicas = buildExperimentReplicas(config.configurable);
+  const callbacks: BaseCallbackHandler[] | undefined = replicas
+    ? [new LangChainTracer({ replicas })]
+    : undefined;
+
   for await (const data of graph.streamEvents(input, {
     ...config,
     version: "v2",
@@ -721,6 +735,7 @@ async function* streamEventsRequest(
     subgraphs: payload.subgraphs,
     interruptBefore,
     interruptAfter,
+    ...(callbacks ? { callbacks } : {}),
   })) {
     // TODO: upstream this fix to LangGraphJS
     if (streamMode.length === 1 && !Array.isArray(data.data.chunk)) {

langgraph_api-0.8.7/langgraph_api/js/src/utils/experiment-tracing.mts

@@ -0,0 +1,51 @@
+// Helpers for routing studio-experiment runs to a separate LangSmith project
+// when a JS graph is invoked via the Node sidecar.
+//
+// The Python worker (api/langgraph_api/stream.py) reads the run-creation
+// payload's `langsmith_tracer` field and stores it under the reserved
+// configurable keys `__langsmith_project__` / `__langsmith_example_id__`
+// (see api/langgraph_api/models/run.py). For Python graphs it then wraps
+// execution in `langsmith.tracing_context(replicas=[...])`. Python contextvars
+// don't cross the HTTP boundary into the JS sidecar, so we read the same
+// reserved keys here and produce an equivalent replica list that the JS
+// sidecar can pass to a `LangChainTracer`.
+
+export interface ExperimentReplica {
+  projectName: string;
+  updates?: { reference_example_id: string };
+}
+
+/**
+ * Build the LangSmith tracing replicas for a JS streamEvents call.
+ *
+ * Returns `undefined` when the run was not dispatched as part of a studio
+ * experiment (i.e. `__langsmith_project__` is not set). When set, returns
+ * two replicas mirroring the Python worker:
+ *   1. the experiment project (carrying `reference_example_id` when an
+ *      example_id is present) — links runs to dataset rows in the experiment
+ *      view.
+ *   2. the deployment's env-default project (`LANGSMITH_PROJECT` /
+ *      `LANGCHAIN_PROJECT`) — keeps the deployment-level trace stream
+ *      unchanged for non-experiment observability.
+ */
+export function buildExperimentReplicas(
+  configurable: Record<string, unknown> | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): ExperimentReplica[] | undefined {
+  const lsProject = configurable?.["__langsmith_project__"];
+  if (typeof lsProject !== "string" || lsProject.length === 0) return undefined;
+
+  const lsExampleId = configurable?.["__langsmith_example_id__"];
+  const envProject =
+    env.LANGSMITH_PROJECT ?? env.LANGCHAIN_PROJECT ?? "default";
+
+  return [
+    {
+      projectName: lsProject,
+      ...(typeof lsExampleId === "string" && lsExampleId.length > 0
+        ? { updates: { reference_example_id: lsExampleId } }
+        : {}),
+    },
+    { projectName: envProject },
+  ];
+}