langgraph-api 0.0.37__py3-none-any.whl → 0.0.39__py3-none-any.whl

langgraph_api/api/__init__.py

@@ -140,9 +140,9 @@ if "inmem" in MIGRATIONS_PATH:
     async def truncate(request: Request):
         from langgraph_storage.checkpoint import Checkpointer
 
-        Checkpointer().clear()
+        await asyncio.to_thread(Checkpointer().clear)
         async with connect() as conn:
-            conn.clear()
+            await asyncio.to_thread(conn.clear)
         return JSONResponse({"ok": True})
 
     routes.insert(0, Route("/internal/truncate", truncate, methods=["POST"]))

langgraph_api/api/mcp.py

@@ -351,7 +351,9 @@ async def handle_tools_list(
 
     # 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)
+    assistants = await client.assistants.search(
+        offset=cursor, limit=DEFAULT_PAGE_SIZE, headers=request.headers
+    )
 
     if len(assistants) == DEFAULT_PAGE_SIZE:
         next_cursor = cursor + DEFAULT_PAGE_SIZE
@@ -370,7 +372,7 @@ async def handle_tools_list(
         else:
             seen_names.add(name)
 
-        schemas = await client.assistants.get_schemas(id_)
+        schemas = await client.assistants.get_schemas(id_, headers=request.headers)
         tools.append(
             {
                 "name": name,
@@ -408,7 +410,9 @@ async def handle_tools_call(
         }
 
     arguments = params.get("arguments", {})
-    assistants = await client.assistants.search(limit=MAX_ASSISTANTS)
+    assistants = await client.assistants.search(
+        limit=MAX_ASSISTANTS, headers=request.headers
+    )
     matching_assistant = [
         assistant for assistant in assistants if assistant["name"] == tool_name
     ]
@@ -437,7 +441,11 @@ async def handle_tools_call(
         tool_name = matching_assistant[0]["assistant_id"]
 
     value = await client.runs.wait(
-        thread_id=None, assistant_id=tool_name, input=arguments, raise_error=False
+        thread_id=None,
+        assistant_id=tool_name,
+        input=arguments,
+        raise_error=False,
+        headers=request.headers,
     )
 
     if "__error__" in value:

langgraph_api/auth/custom.py

@@ -379,13 +379,16 @@ def _depends() -> Any:
         return None
 
 
+_EXCLUDED = ("values", "keys", "items", "dict")
+
+
 class DotDict:
     def __init__(self, dictionary: dict[str, Any]):
         self._dict = dictionary
         for key, value in dictionary.items():
             if isinstance(value, dict):
                 setattr(self, key, DotDict(value))
-            else:
+            elif key not in _EXCLUDED:
                 setattr(self, key, value)
 
     def __getattr__(self, name):
@@ -393,6 +396,9 @@ class DotDict:
             raise AttributeError(f"'DotDict' object has no attribute '{name}'")
         return self._dict[name]
 
+    def __contains__(self, key: str) -> bool:
+        return key in self._dict
+
     def __getitem__(self, key):
         return self._dict[key]
 
@@ -409,6 +415,21 @@ class DotDict:
     def dict(self):
         return self._dict
 
+    def items(self):
+        return self._dict.items()
+
+    def values(self):
+        return self._dict.values()
+
+    def keys(self):
+        return self._dict.keys()
+
+    def __iter__(self):
+        return iter(self._dict)
+
+    def __len__(self):
+        return len(self._dict)
+
 
 class ProxyUser(BaseUser):
     """A proxy that wraps a user object to ensure it has all BaseUser properties.
@@ -462,6 +483,9 @@ class ProxyUser(BaseUser):
             **d,
         }
 
+    def __contains__(self, key: str) -> bool:
+        return key in self._user
+
     def __getitem__(self, key):
         return self._user[key]
 

langgraph_api/cli.py

@@ -131,6 +131,7 @@ def run_server(
     http: typing.Optional["HttpConfig"] = None,
     studio_url: str | None = None,
     disable_persistence: bool = False,
+    allow_blocking: bool = False,
     **kwargs: typing.Any,
 ):
     """Run the LangGraph API server."""
@@ -191,6 +192,8 @@ def run_server(
         LANGGRAPH_HTTP=json.dumps(http) if http else None,
         LANGGRAPH_API_URL=local_url,
         LANGGRAPH_DISABLE_FILE_PERSISTENCE=str(disable_persistence).lower(),
+        # If true, we will not raise on blocking IO calls (via blockbuster)
+        LANGGRAPH_ALLOW_BLOCKING=str(allow_blocking).lower(),
         # See https://developer.chrome.com/blog/private-network-access-update-2024-03
         ALLOW_PRIVATE_NETWORK="true",
     )

langgraph_api/config.py

@@ -304,3 +304,5 @@ USES_INDEXING = (
     and STORE_CONFIG.get("index").get("embed")
 )
 USES_CUSTOM_APP = HTTP_CONFIG and HTTP_CONFIG.get("app")
+
+API_VARIANT = env("LANGSMITH_LANGGRAPH_API_VARIANT", cast=str, default="")

langgraph_api/graph.py

@@ -6,6 +6,7 @@ import inspect
 import json
 import os
 import sys
+import warnings
 from collections.abc import AsyncIterator, Callable
 from contextlib import asynccontextmanager
 from itertools import filterfalse
@@ -22,6 +23,7 @@ from langgraph.store.base import BaseStore
 from starlette.exceptions import HTTPException
 
 from langgraph_api import asyncio as lg_asyncio
+from langgraph_api import config
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.schema import Config
 
@@ -111,18 +113,14 @@ async def get_graph(
                 status_code=424,
                 detail=f"Graph '{graph_id}' is not valid. Review graph registration.",
             )
-        if isinstance(graph_obj, BaseRemotePregel):
-            graph_obj.checkpointer = checkpointer
-            graph_obj.name = graph_id
-            yield graph_obj
-            return
-
         update = {
             "checkpointer": checkpointer,
             "store": store,
         }
         if graph_obj.name == "LangGraph":
             update["name"] = graph_id
+        if isinstance(graph_obj, BaseRemotePregel):
+            update["config"] = config
         yield graph_obj.copy(update=update)
 
 
@@ -237,7 +235,7 @@ async def collect_graphs_from_env(register: bool = False) -> None:
     py_specs = list(filterfalse(is_js_spec, specs))
 
     if js_specs:
-        if os.environ.get("LANGSMITH_LANGGRAPH_API_VARIANT") == "local_dev":
+        if config.API_VARIANT == "local_dev":
             raise NotImplementedError(
                 "LangGraph.JS graphs are not yet supported in local development mode. "
                 "To run your JS graphs, either use the LangGraph Studio application "
@@ -270,7 +268,7 @@ async def collect_graphs_from_env(register: bool = False) -> None:
         await wait_until_js_ready()
 
         for spec in js_specs:
-            graph = RemotePregel.load(graph_id=spec.id)
+            graph = RemotePregel(graph_id=spec.id)
             if register:
                 await register_graph(spec.id, graph, spec.config)
 
@@ -316,7 +314,7 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
             modspec.loader.exec_module(module)
         except ImportError as e:
             e.add_note(f"Could not import python module for graph:\n{spec}")
-            if os.environ.get("LANGSMITH_LANGGRAPH_API_VARIANT") == "local_dev":
+            if config.API_VARIANT == "local_dev":
                 e.add_note(
                     "This error likely means you haven't installed your project and its dependencies yet. Before running the server, install your project:\n\n"
                     "If you are using requirements.txt:\n"
@@ -374,7 +372,29 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
         elif isinstance(graph, Graph):
             graph = graph.compile()
         elif isinstance(graph, Pregel):
-            pass
+            # We don't want to fail real deployments, but this will help folks catch unnecessary custom components
+            # before they deploy
+            if config.API_VARIANT == "local_dev":
+                has_checkpointer = graph.checkpointer is not None
+                has_store = graph.store is not None
+                if has_checkpointer or has_store:
+                    components = []
+                    if has_checkpointer:
+                        components.append("checkpointer")
+                    if has_store:
+                        components.append("store")
+                    component_list = " and ".join(components)
+
+                    raise ValueError(
+                        f"Heads up! Your graph '{spec.variable}' from '{spec.path}' includes a custom {component_list}. "
+                        f"With LangGraph API, persistence is handled automatically by the platform, "
+                        f"so providing a custom {component_list} here isn't necessary and will be ignored when deployed.\n\n"
+                        f"To simplify your setup and use the built-in persistence, please remove the custom {component_list} "
+                        f"from your graph definition. If you are looking to customize which postgres database to connect to,"
+                        " please set the `POSTGRES_URI_CUSTOM` environment variable."
+                        " See https://langchain-ai.github.io/langgraph/cloud/reference/env_var/#postgres_uri_custom for more details."
+                    )
+
         else:
             raise ValueError(
                 f"Variable '{spec.variable}' in module '{spec.path}' is not a Graph or Graph factory function"
@@ -466,7 +486,7 @@ def resolve_embeddings(index_config: dict) -> "Embeddings":
 
         except ImportError as e:
             e.add_note(f"Could not import embeddings module:\n{module_name}\n\n")
-            if os.environ.get("LANGSMITH_LANGGRAPH_API_VARIANT") == "local_dev":
+            if config.API_VARIANT == "local_dev":
                 e.add_note(
                     "If you're in development mode, make sure you've installed your project "
                     "and its dependencies:\n"
@@ -488,4 +508,10 @@ def resolve_embeddings(index_config: dict) -> "Embeddings":
                 " or specify 'embed' as a path to a "
                 "variable in a Python file instead."
             )
-        return init_embeddings(embed)
+        # Capture warnings
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message=("The function `init_embeddings` is in beta."),
+            )
+            return init_embeddings(embed)

langgraph_api/js/base.py

@@ -1,9 +1,12 @@
 from langchain_core.runnables import Runnable
 
+from langgraph_api.schema import Config
+
 
 class BaseRemotePregel(Runnable):
-    # TODO: implement name overriding
     name: str = "LangGraph"
 
-    # TODO: implement graph_id overriding
     graph_id: str
+
+    # Config passed from get_graph()
+    config: Config

langgraph_api/js/build.mts

@@ -54,14 +54,21 @@ async function main() {
     .record(z.string())
     .parse(JSON.parse(process.env.LANGGRAPH_UI || "{}"));
 
+  const uiConfig = z
+    .object({ shared: z.array(z.string()).optional() })
+    .parse(JSON.parse(process.env.LANGGRAPH_UI_CONFIG || "{}"));
+
   if (Object.keys(uiSpecs).length > 0) {
     try {
       const schemas: Record<string, { assets: string[]; name: string }> = {};
       await Promise.all(
-        Object.entries(uiSpecs).map(async ([graphId, uiUserPath]) => {
+        Object.entries(uiSpecs).map(async ([graphId, userPath]) => {
           console.info(`[${graphId}]: Building UI`);
-          const userPath = path.resolve(process.cwd(), uiUserPath);
-          const files = await build(graphId, userPath);
+          const files = await build(graphId, {
+            userPath,
+            cwd: process.cwd(),
+            config: uiConfig,
+          });
           await Promise.all([
             ...files.map(async (item) => {
               const folder = path.resolve(__dirname, "ui", graphId);

langgraph_api/js/client.mts

@@ -42,6 +42,7 @@ import {
   resolveGraph,
   GraphSpec,
   filterValidGraphSpecs,
+  type CompiledGraphFactory,
 } from "./src/graph.mts";
 import { asyncExitHook, gracefulExit } from "exit-hook";
 import { awaitAllCallbacks } from "@langchain/core/callbacks/promises";
@@ -79,13 +80,44 @@ const logger = createLogger({
 });
 
 let GRAPH_SCHEMA: Record<string, Record<string, GraphSchema> | false> = {};
-const GRAPH_RESOLVED: Record<string, CompiledGraph<string>> = {};
+let GRAPH_OPTIONS: {
+  checkpointer?: BaseCheckpointSaver<string | number>;
+  store?: BaseStore;
+} = {};
+
+const GRAPH_RESOLVED: Record<
+  string,
+  CompiledGraph<string> | CompiledGraphFactory<string>
+> = {};
 const GRAPH_SPEC: Record<string, GraphSpec> = {};
 
-function getGraph(graphId: string) {
+async function getGraph(
+  graphId: string,
+  config: { configurable?: Record<string, unknown> },
+  name: string | null | undefined
+) {
   if (!GRAPH_RESOLVED[graphId])
     throw new HTTPException(404, { message: `Graph "${graphId}" not found` });
-  return GRAPH_RESOLVED[graphId];
+
+  const resolved =
+    typeof GRAPH_RESOLVED[graphId] === "function"
+      ? await GRAPH_RESOLVED[graphId](config)
+      : GRAPH_RESOLVED[graphId];
+
+  if (GRAPH_OPTIONS.checkpointer) {
+    // @ts-expect-error BaseCheckpointSaver<string | number> != BaseCheckpointSaver<string>
+    resolved.checkpointer = GRAPH_OPTIONS.checkpointer;
+  }
+
+  if (GRAPH_OPTIONS.store) {
+    resolved.store = GRAPH_OPTIONS.store;
+  }
+
+  if (resolved.name == null || resolved.name === "LangGraph") {
+    resolved.name = name ?? undefined;
+  }
+
+  return resolved;
 }
 
 async function getOrExtractSchema(graphId: string) {
@@ -504,6 +536,8 @@ const ExtraStreamModeSchema = z.union([
 
 const StreamEventsPayload = z.object({
   graph_id: z.string(),
+  graph_name: z.string().nullish(),
+  graph_config: RunnableConfigSchema.nullish(),
   input: z.unknown(),
   command: z.object({ resume: z.unknown() }).nullish(),
   stream_mode: z
@@ -519,7 +553,8 @@ async function* streamEventsRequest(
   rawPayload: z.infer<typeof StreamEventsPayload>
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
-  const graph = getGraph(graphId);
+  const config = getRunnableConfig(payload.config);
+  const graph = await getGraph(graphId, config, payload.graph_name);
 
   const input = payload.command ? new Command(payload.command) : payload.input;
 
@@ -545,8 +580,6 @@ async function* streamEventsRequest(
     }
   }
 
-  const config = getRunnableConfig(payload.config);
-
   const messages: Record<string, BaseMessageChunk> = {};
   const completedIds = new Set<string>();
 
@@ -648,13 +681,20 @@ async function* streamEventsRequest(
 
 const GetGraphPayload = z.object({
   graph_id: z.string(),
+  graph_name: z.string().nullish(),
+  graph_config: RunnableConfigSchema.nullish(),
   config: RunnableConfigSchema.nullish(),
   xray: z.union([z.number(), z.boolean()]).nullish(),
 });
 
 async function getGraphRequest(rawPayload: z.infer<typeof GetGraphPayload>) {
   const { graph_id: graphId, ...payload } = rawPayload;
-  const graph = getGraph(graphId);
+
+  const graph = await getGraph(
+    graphId,
+    getRunnableConfig(payload.graph_config),
+    payload.graph_name
+  );
 
   const drawable = await graph.getGraphAsync({
     ...getRunnableConfig(payload.config),
@@ -665,6 +705,8 @@ async function getGraphRequest(rawPayload: z.infer<typeof GetGraphPayload>) {
 
 const GetSubgraphsPayload = z.object({
   graph_id: z.string(),
+  graph_config: RunnableConfigSchema.nullish(),
+  graph_name: z.string().nullish(),
   namespace: z.string().nullish(),
   recurse: z.boolean().nullish(),
 });
@@ -673,7 +715,8 @@ async function getSubgraphsRequest(
   rawPayload: z.infer<typeof GetSubgraphsPayload>
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
-  const graph = getGraph(graphId);
+  const graphConfig = getRunnableConfig(payload.graph_config);
+  const graph = await getGraph(graphId, graphConfig, payload.graph_name);
   const result: Array<[name: string, Record<string, any>]> = [];
 
   const graphSchema = await getOrExtractSchema(graphId);
@@ -696,13 +739,16 @@ async function getSubgraphsRequest(
 
 const GetStatePayload = z.object({
   graph_id: z.string(),
+  graph_config: RunnableConfigSchema.nullish(),
+  graph_name: z.string().nullish(),
   config: RunnableConfigSchema,
   subgraphs: z.boolean().nullish(),
 });
 
 async function getStateRequest(rawPayload: z.infer<typeof GetStatePayload>) {
   const { graph_id: graphId, ...payload } = rawPayload;
-  const graph = getGraph(graphId);
+  const graphConfig = getRunnableConfig(payload.graph_config);
+  const graph = await getGraph(graphId, graphConfig, payload.graph_name);
 
   const state = await graph.getState(getRunnableConfig(payload.config), {
     subgraphs: payload.subgraphs ?? undefined,
@@ -714,6 +760,8 @@ async function getStateRequest(rawPayload: z.infer<typeof GetStatePayload>) {
 
 const UpdateStatePayload = z.object({
   graph_id: z.string(),
+  graph_config: RunnableConfigSchema.nullish(),
+  graph_name: z.string().nullish(),
   config: RunnableConfigSchema,
   values: z.unknown(),
   as_node: z.string().nullish(),
@@ -723,7 +771,8 @@ async function updateStateRequest(
   rawPayload: z.infer<typeof UpdateStatePayload>
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
-  const graph = getGraph(graphId);
+  const graphConfig = getRunnableConfig(payload.graph_config);
+  const graph = await getGraph(graphId, graphConfig, payload.graph_name);
 
   const config = await graph.updateState(
     getRunnableConfig(payload.config),
@@ -734,10 +783,16 @@ async function updateStateRequest(
   return config;
 }
 
-const GetSchemaPayload = z.object({ graph_id: z.string() });
+const GetSchemaPayload = z.object({
+  graph_id: z.string(),
+  graph_config: RunnableConfigSchema.nullish(),
+  graph_name: z.string().nullish(),
+});
 
 async function getSchemaRequest(payload: z.infer<typeof GetSchemaPayload>) {
   const { graph_id: graphId } = payload;
+  // TODO: add support for schema inference with dynamic graphs (now that Zod is supported)
+
   const schemas = await getOrExtractSchema(graphId);
   const rootGraphId = Object.keys(schemas).find((i) => !i.includes("|"));
   if (!rootGraphId) {
@@ -748,6 +803,8 @@ async function getSchemaRequest(payload: z.infer<typeof GetSchemaPayload>) {
 
 const GetStateHistoryPayload = z.object({
   graph_id: z.string(),
+  graph_config: RunnableConfigSchema.nullish(),
+  graph_name: z.string().nullish(),
   config: RunnableConfigSchema,
   limit: z.number().nullish(),
   before: RunnableConfigSchema.nullish(),
@@ -758,7 +815,8 @@ async function* getStateHistoryRequest(
   rawPayload: z.infer<typeof GetStateHistoryPayload>
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
-  const graph = getGraph(graphId);
+  const config = getRunnableConfig(payload.graph_config);
+  const graph = await getGraph(graphId, config, payload.graph_name);
 
   for await (const item of graph.getStateHistory(
     getRunnableConfig(payload.config),
@@ -776,8 +834,11 @@ const __dirname = new URL(".", import.meta.url).pathname;
 
 async function main() {
   const app = new Hono();
-  const checkpointer = new RemoteCheckpointer();
-  const store = new RemoteStore();
+
+  GRAPH_OPTIONS = {
+    checkpointer: new RemoteCheckpointer(),
+    store: new RemoteStore(),
+  };
 
   const specs = filterValidGraphSpecs(
     z.record(z.string()).parse(JSON.parse(process.env.LANGSERVE_GRAPHS ?? "{}"))
@@ -800,12 +861,6 @@ async function main() {
       logger.info(`Resolving graph ${graphId}`);
       const { resolved, ...spec } = await resolveGraph(rawSpec);
 
-      // TODO: make sure the types do not need to be upfront
-      // @ts-expect-error Overriding checkpointer with different value type
-      resolved.checkpointer = checkpointer;
-      resolved.store = store;
-
-      // registering the graph runtime
       GRAPH_RESOLVED[graphId] = resolved;
       GRAPH_SPEC[graphId] = spec;
     })

langgraph_api/js/global.d.ts

@@ -2,6 +2,7 @@ declare namespace NodeJS {
   interface ProcessEnv {
     LANGSERVE_GRAPHS: string;
     LANGGRAPH_UI?: string;
+    LANGGRAPH_UI_CONFIG?: string;
     PORT: string;
   }
 }

langgraph_api/js/package.json

@@ -24,14 +24,14 @@
     "undici": "^6.21.1",
     "uuid": "^10.0.0",
     "winston": "^3.17.0",
-    "@langchain/langgraph-api": "~0.0.14",
+    "@langchain/langgraph-api": "~0.0.19",
     "zod": "^3.23.8"
   },
   "resolutions": {
     "esbuild": "^0.25.0"
   },
   "devDependencies": {
-    "@langchain/langgraph-sdk": "^0.0.31",
+    "@langchain/langgraph-sdk": "^0.0.60",
     "@types/react": "^19.0.8",
     "@types/react-dom": "^19.0.3",
     "@types/node": "^22.2.0",

langgraph_api/js/remote.py

@@ -5,7 +5,7 @@ import shutil
 import ssl
 from collections.abc import AsyncIterator
 from contextlib import AbstractContextManager
-from typing import Any, Literal
+from typing import Any, Literal, Self
 
 import certifi
 import httpx
@@ -34,6 +34,7 @@ from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.js.errors import RemoteException
 from langgraph_api.js.sse import SSEDecoder, aiter_lines_raw
 from langgraph_api.route import ApiResponse
+from langgraph_api.schema import Config
 from langgraph_api.serde import json_dumpb
 from langgraph_api.utils import AsyncConnectionProto
 
@@ -89,11 +90,16 @@ async def _client_invoke(method: str, data: dict[str, Any]):
 
 
 class RemotePregel(BaseRemotePregel):
-    @staticmethod
-    def load(graph_id: str):
-        model = RemotePregel()
-        model.graph_id = graph_id
-        return model
+    def __init__(
+        self,
+        graph_id: str,
+        *,
+        config: Config | None = None,
+        **kwargs: Any,
+    ):
+        super().__init__()
+        self.graph_id = graph_id
+        self.config = config
 
     async def astream_events(
         self,
@@ -108,6 +114,8 @@ class RemotePregel(BaseRemotePregel):
 
         data = {
             "graph_id": self.graph_id,
+            "graph_config": self.config,
+            "graph_name": self.name,
             "command" if isinstance(input, Command) else "input": input,
             "config": config,
             **kwargs,
@@ -129,7 +137,14 @@ class RemotePregel(BaseRemotePregel):
         xray: int | bool = False,
     ) -> DrawableGraph:
         response = await _client_invoke(
-            "getGraph", {"graph_id": self.graph_id, "config": config, "xray": xray}
+            "getGraph",
+            {
+                "graph_id": self.graph_id,
+                "graph_config": self.config,
+                "graph_name": self.name,
+                "config": config,
+                "xray": xray,
+            },
         )
 
         nodes: list[Any] = response.pop("nodes")
@@ -157,11 +172,22 @@ class RemotePregel(BaseRemotePregel):
         )
 
     async def fetch_subgraphs(
-        self, *, namespace: str | None = None, recurse: bool = False
+        self,
+        *,
+        namespace: str | None = None,
+        config: RunnableConfig | None = None,
+        recurse: bool = False,
     ) -> dict[str, dict]:
         return await _client_invoke(
             "getSubgraphs",
-            {"graph_id": self.graph_id, "namespace": namespace, "recurse": recurse},
+            {
+                "graph_id": self.graph_id,
+                "graph_config": self.config,
+                "graph_name": self.name,
+                "namespace": namespace,
+                "recurse": recurse,
+                "config": config,
+            },
         )
 
     def _convert_state_snapshot(self, item: dict) -> StateSnapshot:
@@ -214,7 +240,13 @@ class RemotePregel(BaseRemotePregel):
         return self._convert_state_snapshot(
             await _client_invoke(
                 "getState",
-                {"graph_id": self.graph_id, "config": config, "subgraphs": subgraphs},
+                {
+                    "graph_id": self.graph_id,
+                    "graph_config": self.config,
+                    "graph_name": self.name,
+                    "config": config,
+                    "subgraphs": subgraphs,
+                },
             )
         )
 
@@ -228,6 +260,8 @@ class RemotePregel(BaseRemotePregel):
             "updateState",
             {
                 "graph_id": self.graph_id,
+                "graph_config": self.config,
+                "graph_name": self.name,
                 "config": config,
                 "values": values,
                 "as_node": as_node,
@@ -247,6 +281,8 @@ class RemotePregel(BaseRemotePregel):
             "getStateHistory",
             {
                 "graph_id": self.graph_id,
+                "graph_config": self.config,
+                "graph_name": self.name,
                 "config": config,
                 "limit": limit,
                 "filter": filter,
@@ -277,6 +313,10 @@ class RemotePregel(BaseRemotePregel):
     async def invoke(self, input: Any, config: RunnableConfig | None = None):
         raise Exception("Not implemented")
 
+    def copy(self, update: dict[str, Any] | None = None) -> Self:
+        attrs = {**self.__dict__, **(update or {})}
+        return self.__class__(**attrs)
+
 
 async def run_js_process(paths_str: str, watch: bool = False):
     # check if tsx is available