Support stringized annotations

libs/langgraph/langgraph/utils/runnable.py

@@ -120,7 +120,10 @@ def __init__(
         # check signature
         if func is None and afunc is None:
             raise ValueError("At least one of func or afunc must be provided.")
-        params = inspect.signature(cast(Callable, func or afunc)).parameters
+        params = inspect.signature(
+            cast(Callable, func or afunc), eval_str=True
+        ).parameters
+
         self.func_accepts_config = "config" in params
         self.func_accepts: dict[str, bool] = {}
         for kw, typ, _, _, _ in KWARGS_CONFIG_KEYS:

libs/langgraph/tests/test_runnable.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any
+
+from langgraph.store.store import Store
+from langgraph.types import StreamWriter
+from langgraph.utils.runnable import RunnableCallable
+
+
+def test_runnable_callable_func_accepts():
+    def sync_func(x: Any) -> str:
+        return f"{x}"
+
+    async def async_func(x: Any) -> str:
+        return f"{x}"
+
+    def func_with_store(x: Any, store: Store) -> str:
+        return f"{x}"
+
+    def func_with_writer(x: Any, writer: StreamWriter) -> str:
+        return f"{x}"
+
+    async def afunc_with_store(x: Any, store: Store) -> str:
+        return f"{x}"
+
+    async def afunc_with_writer(x: Any, writer: StreamWriter) -> str:
+        return f"{x}"
+
+    runnables = {
+        "sync": RunnableCallable(sync_func),
+        "async": RunnableCallable(func=None, afunc=async_func),
+        "with_store": RunnableCallable(func_with_store),
+        "with_writer": RunnableCallable(func_with_writer),
+        "awith_store": RunnableCallable(afunc_with_store),
+        "awith_writer": RunnableCallable(afunc_with_writer),
+    }
+
+    expected_store = {"with_store": True, "awith_store": True}
+    expected_writer = {"with_writer": True, "awith_writer": True}
+
+    for name, runnable in runnables.items():
+        assert runnable.func_accepts["writer"] == expected_writer.get(name, False)
+        assert runnable.func_accepts["store"] == expected_store.get(name, False)