async def {name}_node(state: ResearchState) -> dict:
    """Description of what this node does."""
    llm = get_llm()

    # Extract state with .get() defaults (IMPORTANT for LangGraph Studio)
    topic = state.get("topic", "")
    findings = state.get("findings", [])

    messages = [
        SystemMessage(content={NAME}_SYSTEM),
        HumanMessage(content={NAME}_USER.format(topic=topic)),
    ]

    response = await llm.ainvoke(messages)
    result = _parse_json_response(response.content)

    return {
        "field_to_update": result,
    }

async def {name}_node(
    state: ResearchState,
) -> Command[Literal["next_node_a", "next_node_b"]]:
    """Node with conditional routing."""
    # ... logic ...

    if condition:
        return Command(goto="next_node_a")
    else:
        return Command(
            update={"some_field": value},
            goto="next_node_b"
        )

from langgraph.types import Command, interrupt

async def approval_{name}_node(
    state: ResearchState,
) -> Command[Literal["proceed", "reject"]]:
    """Pause for human approval."""
    review_mode = state.get("review_mode", ReviewMode.AUTONOMOUS)

    if review_mode == ReviewMode.AUTONOMOUS:
        return Command(goto="proceed")

    approval = interrupt({
        "type": "{name}_approval",
        "data": state.get("data_to_review", []),
        "message": "Please review and approve.",
    })

    if approval.get("approved"):
        return Command(goto="proceed")
    else:
        return Command(
            update={"error_message": approval.get("reason", "Rejected")},
            goto="handle_error"
        )

{NAME}_SYSTEM = """You are a specialized assistant for {task}.

Your responsibilities:
1. First responsibility
2. Second responsibility

Output format:
- Always return valid JSON
- Include required fields: field1, field2
"""

{NAME}_USER = """Context:
Topic: {topic}
Previous findings: {findings}

Task: {specific_task}

Return JSON with the following structure:
{{
    "field1": "value",
    "field2": ["item1", "item2"]
}}"""

# In build_research_graph() AND _build_graph_for_cli():

# Add node
builder.add_node("{name}", {name}_node)

# Add edges
builder.add_edge("previous_node", "{name}")  # Incoming edge
# For conditional nodes: NO outgoing edge - Command handles it
# For simple nodes:
builder.add_edge("{name}", "next_node")  # Outgoing edge

class ResearchState(TypedDict):
    # ... existing fields ...

    # For simple fields:
    new_field: str

    # For accumulated lists (multiple nodes can append):
    new_list: Annotated[list[NewType], add]

@pytest.mark.asyncio
async def test_{name}_node_basic():
    """Test {name} node with valid input."""
    state: ResearchState = {
        "topic": "test topic",
        # Add required fields with realistic test data
    }

    result = await {name}_node(state)

    assert "expected_field" in result
    assert isinstance(result["expected_field"], expected_type)


@pytest.mark.asyncio
async def test_{name}_node_empty_state():
    """Test {name} node handles empty state gracefully."""
    state: ResearchState = {"topic": ""}

    result = await {name}_node(state)

    # Should not raise, should return sensible defaults
    assert result is not None

result = _parse_json_response(response.content)

text = _enforce_writing_style(response.content)

# Good
topic = state.get("topic", "")
findings = state.get("findings", [])

# Bad - will fail in LangGraph Studio
topic = state["topic"]