Update LangGraph samples for temporalio 1.27.0 release

- Drop the [tool.uv.sources] git pin; consume temporalio from PyPI now
  that 1.27.0 ships the LangGraph plugin.
- Keep the protoc CI step around as a permanent fixture so we don't have
  to add and remove it each time we iterate on a new plugin sample.
- Replace dict-comprehension activity_options with explicit per-task
  literals in the Functional API samples.
- Emphasize workflow.wait_condition() in the human-in-the-loop READMEs
  as the durable wait primitive that pairs with interrupt() and signals.
- Clarify that the task result cache is provided by the LangGraph plugin
  (Temporal), not by upstream LangGraph.
- Drop "Same pattern as the Graph API version" cross-references from
  Functional API workflow docstrings; readers pick one API style.
- Tighten the Functional API LangSmith tracing README copy.
- Point the parent README to the released contrib package docs.

Author: DABH

.github/workflows/ci.yml

@@ -33,9 +33,10 @@ jobs:
       - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
         with:
           python-version: ${{ matrix.python }}
-      # protoc is required to build temporalio from the sdk-python git source
-      # (see [tool.uv.sources] in pyproject.toml). Drop this step once the SDK
-      # ships a release that includes the LangGraph plugin.
+      # protoc is needed whenever uv builds temporalio from a git source
+      # (e.g. when [tool.uv.sources] pins a branch while a feature is in
+      # development). Kept on by default so we don't have to add and remove
+      # this step every time we iterate on a new plugin.
       - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3
         with:
           version: "23.x"

langgraph_plugin/README.md

@@ -1,6 +1,6 @@
 # LangGraph Plugin Samples
 
-These samples demonstrate the [Temporal LangGraph plugin](https://github.com/temporalio/sdk-python/pull/1448), which runs LangGraph workflows as durable Temporal workflows. Each LangGraph graph node (Graph API) or `@task` (Functional API) executes as a Temporal activity with automatic retries, timeouts, and crash recovery.
+These samples demonstrate the [Temporal LangGraph plugin](https://github.com/temporalio/sdk-python/tree/main/temporalio/contrib/langgraph), which runs LangGraph workflows as durable Temporal workflows. Each LangGraph graph node (Graph API) or `@task` (Functional API) executes as a Temporal activity with automatic retries, timeouts, and crash recovery.
 
 Samples are organized by API style:
 
@@ -70,4 +70,4 @@ uv run langgraph_plugin/<api>/langsmith_tracing/main.py
 
 ## Related
 
-- [SDK PR: LangGraph plugin](https://github.com/temporalio/sdk-python/pull/1448)
+- [Temporal LangGraph plugin docs](https://github.com/temporalio/sdk-python/tree/main/temporalio/contrib/langgraph)

langgraph_plugin/functional_api/continue_as_new/README.md

@@ -1,6 +1,6 @@
 # Continue-as-New with Caching (Functional API)
 
-Demonstrates combining Temporal's continue-as-new with LangGraph's task result caching to avoid re-executing completed `@task` functions across workflow boundaries.
+Demonstrates combining Temporal's continue-as-new with the LangGraph plugin's task result cache to avoid re-executing completed `@task` functions across workflow boundaries.
 
 ## What This Sample Demonstrates
 

langgraph_plugin/functional_api/continue_as_new/workflow.py

@@ -1,7 +1,8 @@
 """Continue-as-new with caching using the LangGraph Functional API with Temporal.
 
-Demonstrates Temporal's continue-as-new with LangGraph's task result caching
-to avoid re-executing completed @task functions across workflow boundaries.
+Demonstrates Temporal's continue-as-new with the LangGraph plugin's task
+result cache to avoid re-executing completed @task functions across
+workflow boundaries.
 """
 
 from dataclasses import dataclass
@@ -41,14 +42,21 @@ async def pipeline_entrypoint(data: int) -> dict:
     return {"result": tripled}
 
 
-all_tasks: list[Any] = [double, add_50, triple]
+all_tasks = [double, add_50, triple]
 
 activity_options = {
-    t.func.__name__: {
+    "double": {
         "execute_in": "activity",
         "start_to_close_timeout": timedelta(seconds=30),
-    }
-    for t in all_tasks
+    },
+    "add_50": {
+        "execute_in": "activity",
+        "start_to_close_timeout": timedelta(seconds=30),
+    },
+    "triple": {
+        "execute_in": "activity",
+        "start_to_close_timeout": timedelta(seconds=30),
+    },
 }
 
 

langgraph_plugin/functional_api/control_flow/workflow.py

@@ -7,7 +7,6 @@
 """
 
 from datetime import timedelta
-from typing import Any
 
 from langgraph.func import entrypoint, task
 from temporalio import workflow
@@ -75,7 +74,7 @@ async def control_flow_pipeline(items: list[str]) -> dict:
     return {"results": results, "summary": summary_text, "total": len(results)}
 
 
-all_tasks: list[Any] = [
+all_tasks = [
     validate_item,
     classify_item,
     process_urgent,
@@ -84,11 +83,26 @@ async def control_flow_pipeline(items: list[str]) -> dict:
 ]
 
 activity_options = {
-    t.func.__name__: {
+    "validate_item": {
         "execute_in": "activity",
         "start_to_close_timeout": timedelta(seconds=30),
-    }
-    for t in all_tasks
+    },
+    "classify_item": {
+        "execute_in": "activity",
+        "start_to_close_timeout": timedelta(seconds=30),
+    },
+    "process_urgent": {
+        "execute_in": "activity",
+        "start_to_close_timeout": timedelta(seconds=30),
+    },
+    "process_normal": {
+        "execute_in": "activity",
+        "start_to_close_timeout": timedelta(seconds=30),
+    },
+    "summarize": {
+        "execute_in": "activity",
+        "start_to_close_timeout": timedelta(seconds=30),
+    },
 }
 
 

langgraph_plugin/functional_api/human_in_the_loop/README.md

@@ -1,20 +1,21 @@
 # Human-in-the-Loop Chatbot (Functional API)
 
-Demonstrates using LangGraph's `interrupt()` to pause an entrypoint for human review, combined with Temporal signals and queries for asynchronous feedback, using the imperative `@task`/`@entrypoint` style.
+Demonstrates pausing an entrypoint with LangGraph's `interrupt()` and waiting indefinitely for human review with Temporal's `workflow.wait_condition()`. A Temporal signal delivers the human's feedback; a Temporal query exposes the pending draft to UIs.
 
 ## What This Sample Demonstrates
 
-- Using `interrupt()` inside a `@task` to pause for human input
-- Temporal signals and queries for asynchronous human feedback
+- `workflow.wait_condition()` to block the Workflow until human input arrives — for as long as it takes, with no polling and no timeout
+- `interrupt()` inside a `@task` to pause the entrypoint at the review point
+- Temporal **signals** to deliver human feedback and **queries** to expose the pending draft
 - Resuming with `Command(resume=...)` via the v2 API
 - Setting a checkpointer on the entrypoint for interrupt/resume support
 
 ## How It Works
 
 1. The `generate_draft` task produces a draft response.
 2. The `request_human_review` task calls `interrupt(draft)`, pausing the entrypoint.
-3. The workflow stores the draft and waits for a signal.
-4. After receiving feedback, the entrypoint resumes and returns the result.
+3. The Workflow stores the draft (visible via the query) and calls `workflow.wait_condition()` — blocking durably until the signal sets `_human_input`. This can wait indefinitely; Temporal persists the state.
+4. After the signal arrives, the entrypoint resumes with `Command(resume=...)` and returns the final response.
 
 ## Running the Sample
 

langgraph_plugin/functional_api/human_in_the_loop/workflow.py

@@ -1,6 +1,8 @@
 """Human-in-the-loop chatbot using the LangGraph Functional API with Temporal.
 
-Same pattern as the Graph API version, but using @task and @entrypoint decorators.
+The @entrypoint pauses at interrupt(); the Workflow waits indefinitely with
+workflow.wait_condition() until a Temporal signal delivers human feedback,
+then resumes the entrypoint with Command(resume=...).
 """
 
 from datetime import timedelta
@@ -40,14 +42,17 @@ async def chatbot_entrypoint(user_message: str) -> dict:
     return {"response": final_response}
 
 
-all_tasks: list[Any] = [generate_draft, request_human_review]
+all_tasks = [generate_draft, request_human_review]
 
 activity_options = {
-    t.func.__name__: {
+    "generate_draft": {
         "execute_in": "activity",
         "start_to_close_timeout": timedelta(seconds=30),
-    }
-    for t in all_tasks
+    },
+    "request_human_review": {
+        "execute_in": "activity",
+        "start_to_close_timeout": timedelta(seconds=30),
+    },
 }
 
 

langgraph_plugin/functional_api/langsmith_tracing/README.md

@@ -1,6 +1,6 @@
 # LangSmith Tracing (Functional API)
 
-Demonstrates combining `LangGraphPlugin` (durable task execution) with Temporal's `LangSmithPlugin` (observability) for full tracing of LLM calls through Temporal workflows, using LangGraph's `@task` and `@entrypoint` decorators.
+Demonstrates combining `LangGraphPlugin` (durable task execution) with Temporal's `LangSmithPlugin` for full tracing of LLM calls through Temporal workflows, using LangGraph's `@task` and `@entrypoint` decorators.
 
 ## What This Sample Demonstrates
 

langgraph_plugin/functional_api/react_agent/workflow.py

@@ -1,12 +1,10 @@
 """ReAct agent using the LangGraph Functional API with Temporal.
 
-Same pattern as the Graph API version, but using @task and @entrypoint.
-The Functional API naturally expresses the ReAct loop as a while loop,
-making the control flow explicit and easy to extend.
+The Functional API expresses the ReAct loop as a plain `while` loop, making
+the control flow explicit and easy to extend.
 """
 
 from datetime import timedelta
-from typing import Any
 
 from langgraph.func import entrypoint, task
 from temporalio import workflow
@@ -69,14 +67,17 @@ async def react_agent_entrypoint(query: str) -> dict:
         history.append(result)
 
 
-all_tasks: list[Any] = [agent_think, execute_tool]
+all_tasks = [agent_think, execute_tool]
 
 activity_options = {
-    t.func.__name__: {
+    "agent_think": {
         "execute_in": "activity",
         "start_to_close_timeout": timedelta(seconds=30),
-    }
-    for t in all_tasks
+    },
+    "execute_tool": {
+        "execute_in": "activity",
+        "start_to_close_timeout": timedelta(seconds=30),
+    },
 }
 
 

langgraph_plugin/graph_api/continue_as_new/README.md

@@ -1,11 +1,11 @@
 # Continue-as-New with Caching (Graph API)
 
-Demonstrates Temporal's continue-as-new with LangGraph's task result caching to avoid re-executing completed graph nodes across workflow boundaries.
+Demonstrates combining Temporal's continue-as-new with the LangGraph plugin's task result cache to avoid re-executing completed graph nodes across workflow boundaries.
 
 ## What This Sample Demonstrates
 
 - Using `workflow.continue_as_new()` to reset event history for long-running pipelines
-- Capturing task results with `cache()` before continuing
+- Capturing node results with `cache()` before continuing
 - Restoring cached results with `temporal_graph(name, cache=...)` so completed nodes are skipped
 - Each node executes exactly once despite multiple workflow invocations