feat(cli): add Temporal + LangGraph agent template

Adds a `temporal-langgraph` init template (and registers it in the
Temporal submenu of `agentex init`), filling the gap left by the
existing `temporal-openai-agents` and `temporal-pydantic-ai` templates —
LangGraph previously only had `default-langgraph` and `sync-langgraph`.

Pattern: Temporal as the runtime, LangGraph as the agent framework. The
workflow walks the LangGraph agent loop but dispatches each node as a
durable Temporal activity (one per LLM call, one per tool call) — the
"Temporal in the agent loop" pattern, implemented with the released SDK
and stock LangGraph (no unreleased plugin required). Showcases:

- nodes-as-activities (call_model_activity / execute_tool_activity)
- human-in-the-loop tool gating via a Temporal signal (provide_approval)
- live introspection queries (status, pending approval, graph
  mermaid/ascii, graph state)
- token streaming to Agentex, multi-turn memory on the workflow, tracing

Also adds tests/lib/cli/test_init_templates.py, which renders every init
template and asserts the output is valid, substituted Python (catching
.j2 templating regressions), with focused coverage of the new template.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: danielmillerp

src/agentex/lib/cli/commands/init.py

@@ -25,6 +25,7 @@ class TemplateType(str, Enum):
     TEMPORAL = "temporal"
     TEMPORAL_OPENAI_AGENTS = "temporal-openai-agents"
     TEMPORAL_PYDANTIC_AI = "temporal-pydantic-ai"
+    TEMPORAL_LANGGRAPH = "temporal-langgraph"
     DEFAULT = "default"
     DEFAULT_LANGGRAPH = "default-langgraph"
     DEFAULT_PYDANTIC_AI = "default-pydantic-ai"
@@ -64,6 +65,7 @@ def create_project_structure(
         TemplateType.TEMPORAL: ["acp.py", "workflow.py", "run_worker.py"],
         TemplateType.TEMPORAL_OPENAI_AGENTS: ["acp.py", "workflow.py", "run_worker.py", "activities.py"],
         TemplateType.TEMPORAL_PYDANTIC_AI: ["acp.py", "workflow.py", "run_worker.py", "agent.py", "tools.py"],
+        TemplateType.TEMPORAL_LANGGRAPH: ["acp.py", "workflow.py", "run_worker.py", "activities.py", "graph.py", "tools.py"],
         TemplateType.DEFAULT: ["acp.py"],
         TemplateType.DEFAULT_LANGGRAPH: ["acp.py", "graph.py", "tools.py"],
         TemplateType.DEFAULT_PYDANTIC_AI: ["acp.py", "agent.py", "tools.py"],
@@ -195,6 +197,7 @@ def validate_agent_name(text: str) -> bool | str:
                 {"name": "Basic Temporal", "value": TemplateType.TEMPORAL},
                 {"name": "Temporal + OpenAI Agents SDK (Recommended)", "value": TemplateType.TEMPORAL_OPENAI_AGENTS},
                 {"name": "Temporal + Pydantic AI", "value": TemplateType.TEMPORAL_PYDANTIC_AI},
+                {"name": "Temporal + LangGraph", "value": TemplateType.TEMPORAL_LANGGRAPH},
             ],
         ).ask()
         if not template_type:

src/agentex/lib/cli/templates/temporal-langgraph/.dockerignore.j2

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environments
+.env**
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Git
+.git
+.gitignore
+
+# Misc
+.DS_Store 

src/agentex/lib/cli/templates/temporal-langgraph/.env.example.j2

@@ -0,0 +1,13 @@
+# {{ agent_name }} - Environment Variables
+# Copy this file to .env and fill in the values
+
+# API key for your LLM provider
+LITELLM_API_KEY=
+
+# LLM base URL (optional - override to use a different provider)
+# OPENAI_BASE_URL=
+
+# SGP Configuration (optional - for tracing)
+# SGP_API_KEY=
+# SGP_ACCOUNT_ID=
+# SGP_CLIENT_BASE_URL=

src/agentex/lib/cli/templates/temporal-langgraph/Dockerfile-uv.j2

@@ -0,0 +1,55 @@
+# syntax=docker/dockerfile:1.3
+FROM python:3.12-slim
+COPY --from=ghcr.io/astral-sh/uv:0.6.4 /uv /uvx /bin/
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    htop \
+    vim \
+    curl \
+    tar \
+    python3-dev \
+    postgresql-client \
+    build-essential \
+    libpq-dev \
+    gcc \
+    cmake \
+    netcat-openbsd \
+    nodejs \
+    npm \ 
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/**
+
+# Install tctl (Temporal CLI)
+RUN curl -L https://github.com/temporalio/tctl/releases/download/v1.18.1/tctl_1.18.1_linux_arm64.tar.gz -o /tmp/tctl.tar.gz && \
+    tar -xzf /tmp/tctl.tar.gz -C /usr/local/bin && \
+    chmod +x /usr/local/bin/tctl && \
+    rm /tmp/tctl.tar.gz
+
+ENV UV_COMPILE_BYTECODE=1
+ENV UV_LINK_MODE=copy
+ENV UV_HTTP_TIMEOUT=1000
+
+WORKDIR /app/{{ project_path_from_build_root }}
+
+# Copy dependency files for layer caching
+COPY {{ project_path_from_build_root }}/pyproject.toml {{ project_path_from_build_root }}/uv.lock ./
+
+# Install dependencies (without project itself, for layer caching)
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --locked --no-install-project --no-dev
+
+# Copy the project code
+COPY {{ project_path_from_build_root }}/project ./project
+
+# Install the project
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --locked --no-dev
+
+ENV PATH="/app/{{ project_path_from_build_root }}/.venv/bin:$PATH"
+
+# Run the ACP server using uvicorn
+CMD ["uvicorn", "project.acp:acp", "--host", "0.0.0.0", "--port", "8000"]
+
+# When we deploy the worker, we will replace the CMD with the following
+# CMD ["python", "-m", "run_worker"]

src/agentex/lib/cli/templates/temporal-langgraph/Dockerfile.j2

@@ -0,0 +1,48 @@
+# syntax=docker/dockerfile:1.3
+FROM python:3.12-slim
+COPY --from=ghcr.io/astral-sh/uv:0.6.4 /uv /uvx /bin/
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    htop \
+    vim \
+    curl \
+    tar \
+    python3-dev \
+    postgresql-client \
+    build-essential \
+    libpq-dev \
+    gcc \
+    cmake \
+    netcat-openbsd \
+    node \
+    npm \ 
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install tctl (Temporal CLI)
+RUN curl -L https://github.com/temporalio/tctl/releases/download/v1.18.1/tctl_1.18.1_linux_arm64.tar.gz -o /tmp/tctl.tar.gz && \
+    tar -xzf /tmp/tctl.tar.gz -C /usr/local/bin && \
+    chmod +x /usr/local/bin/tctl && \
+    rm /tmp/tctl.tar.gz
+
+RUN uv pip install --system --upgrade pip setuptools wheel
+
+ENV UV_HTTP_TIMEOUT=1000
+
+# Copy just the requirements file to optimize caching
+COPY {{ project_path_from_build_root }}/requirements.txt /app/{{ project_path_from_build_root }}/requirements.txt
+
+WORKDIR /app/{{ project_path_from_build_root }}
+
+# Install the required Python packages
+RUN uv pip install --system -r requirements.txt
+
+# Copy the project code
+COPY {{ project_path_from_build_root }}/project /app/{{ project_path_from_build_root }}/project
+
+# Run the ACP server using uvicorn
+CMD ["uvicorn", "project.acp:acp", "--host", "0.0.0.0", "--port", "8000"]
+
+# When we deploy the worker, we will replace the CMD with the following
+# CMD ["python", "-m", "run_worker"] 

src/agentex/lib/cli/templates/temporal-langgraph/README.md.j2

@@ -0,0 +1,126 @@
+# {{ agent_name }} — AgentEx Temporal + LangGraph
+
+A starter template for building AI agents with AgentEx, [LangGraph](https://langchain-ai.github.io/langgraph/),
+and Temporal — where **Temporal is the runtime and LangGraph is the agent framework**.
+
+The agent loop that LangGraph describes is executed by Temporal: each
+LangGraph node (the model call, each tool call) runs as its own **durable
+Temporal activity**. You get per-node durability, automatic retries, and full
+visibility in the Temporal UI — without LangGraph's own runtime or an external
+checkpoint database.
+
+This is the *Temporal in the agent loop* pattern (Level 2), implemented with
+the released SDK and stock LangGraph — no plugin required.
+
+## What's in the box
+
+- **Durable execution** via a Temporal workflow.
+- **Nodes as activities** — one activity per LLM call, one per tool call
+  (`call_model_activity`, `execute_tool_activity`).
+- **Human-in-the-loop** — sensitive tools pause the loop on a Temporal signal
+  until a human approves or rejects (`provide_approval`).
+- **Live introspection via Temporal queries** — `get_status`,
+  `get_pending_approval`, `get_graph_state`, and `get_graph_mermaid` /
+  `get_graph_ascii` to render the agent graph while it runs.
+- **Streaming responses** — tokens delta-stream to AgentEx via Redis from
+  inside the model activity.
+- **Multi-turn memory** — kept on the workflow instance, durable for free.
+- **Tracing/observability** — a per-turn span shipped to SGP/AgentEx.
+
+## The agent graph
+
+```
+START --> agent --> (tool calls?) --> tools --> agent
+                --> (no tool calls?) --> END
+```
+
+`project/graph.py` defines this graph with LangGraph. The workflow walks the
+same topology, dispatching `agent` and `tools` as activities. Query
+`get_graph_mermaid` at runtime to see it rendered.
+
+## Project structure
+
+```
+{{ project_name }}/
+├── project/
+│   ├── __init__.py
+│   ├── acp.py            # Thin async ACP server (Temporal-wired)
+│   ├── workflow.py       # Temporal runtime: agent loop, HIL, queries, memory
+│   ├── activities.py     # LangGraph nodes as durable activities (model + tools)
+│   ├── graph.py          # LangGraph graph definition + model/message helpers
+│   └── run_worker.py     # Temporal worker setup
+├── Dockerfile
+├── manifest.yaml
+├── environments.yaml
+├── dev.ipynb
+{% if use_uv %}└── pyproject.toml{% else %}└── requirements.txt{% endif %}
+```
+
+## Running the agent
+
+```bash
+{% if use_uv %}agentex uv sync
+source .venv/bin/activate{% else %}pip install -r requirements.txt{% endif %}
+
+# Start the agent (ACP server + Temporal worker)
+agentex agents run --manifest manifest.yaml
+```
+
+The agent starts on port 8000. Open the Temporal UI at http://localhost:8080 to
+watch workflows and activities execute. Use `dev.ipynb` to create a task and
+send messages.
+
+## Human-in-the-loop
+
+Tools listed in `TOOLS_REQUIRING_APPROVAL` (in `project/tools.py`) pause before
+they run. The workflow surfaces the pending call (queryable via
+`get_pending_approval`) and waits — durably, for as long as it takes — for a
+`provide_approval` signal:
+
+```python
+await client.agents.send_signal(  # or via the Temporal client
+    workflow_id=task.id,
+    signal="provide_approval",
+    args=[{"approved": True, "approver": "daniel", "reason": "looks good"}],
+)
+```
+
+If rejected, the rejection is fed back to the model so it can adjust.
+
+## Adding tools
+
+1. Define a `@tool` function in `project/tools.py` and add it to `TOOLS`.
+2. (Optional) add its name to `TOOLS_REQUIRING_APPROVAL` to gate it behind
+   human approval.
+
+That's it — the model is bound with `TOOLS`, and `execute_tool_activity` looks
+up tools by name at runtime, so no other wiring is needed.
+
+## Configuration
+
+Tune the model in `project/graph.py` (`MODEL_NAME`) and the system prompt
+(`SYSTEM_PROMPT`). Activity timeouts and retry policy live at the top of
+`project/workflow.py`.
+
+## Environment variables
+
+Create a `.env` file (see `.env.example`):
+
+```bash
+LITELLM_API_KEY=your-litellm-key   # copied to OPENAI_API_KEY automatically
+# OPENAI_BASE_URL=                 # optional: point at a different provider
+# SGP_API_KEY=                     # optional: tracing
+# SGP_ACCOUNT_ID=                  # optional: tracing
+# SGP_CLIENT_BASE_URL=             # optional: tracing
+```
+
+## Why Temporal as the runtime?
+
+LangGraph open source isn't a complete agent runtime: productionizing it means
+solving state management, checkpoint databases, session recovery after crashes,
+timeouts, and health checks. Temporal provides those out of the box. Here it
+runs your LangGraph agent durably — if the worker crashes mid-turn, another
+worker resumes from the recorded activity results, no LLM re-calls, no lost
+state.
+
+Happy building with Temporal + LangGraph!