You already have options.
Here's where Cleat fits.

from typing import TypedDict
from langgraph.graph import StateGraph, END
import httpx, json

class State(TypedDict):
    repo: str
    pr: int
    result: dict | None

async def analyze(state: State) -> dict:
    # network call — but who knows? caller doesn't.
    url = f"https://api/{state['repo']}/pr/{state['pr']}"
    try:
        async with httpx.AsyncClient() as c:
            r = await c.get(url, timeout=30)
            r.raise_for_status()
            return {"result": r.json()}
    except Exception as e:
        # retry? you're writing it.
        return {"result": None}

graph = StateGraph(State)
graph.add_node("analyze", analyze)
graph.set_entry_point("analyze")
graph.add_edge("analyze", END)
app = graph.compile()

# mocking? monkeypatch httpx, hope nothing else uses it.

from datetime import timedelta
from temporalio import workflow, activity
from temporalio.common import RetryPolicy

@activity.defn
async def fetch_pr(repo: str, pr: int) -> dict:
    # effect is here — but workflow can't call it directly,
    # must use execute_activity. determinism rule.
    ...

@workflow.defn
class AnalyzeWorkflow:
    @workflow.run
    async def run(self, repo: str, pr: int):
        return await workflow.execute_activity(
            fetch_pr, args=[repo, pr],
            start_to_close_timeout=timedelta(seconds=30),
            retry_policy=RetryPolicy(maximum_attempts=3),
        )

# plus: a Worker process, a Temporal Service running
# somewhere, and the discipline to never call random()
# or datetime.now() directly inside a workflow.

from pydantic import BaseModel
import httpx, asyncio
from tenacity import retry, stop_after_attempt

class Analysis(BaseModel):
    files_changed: int
    summary: str

@retry(stop=stop_after_attempt(3))
async def analyze(repo: str, pr: int) -> Analysis:
    # effects: ¯\_(ツ)_/¯
    url = f"https://api/{repo}/pr/{pr}"
    async with httpx.AsyncClient(timeout=30) as c:
        r = await c.get(url)
        r.raise_for_status()
        return Analysis.model_validate(r.json())

# tests: pytest + pytest-mock + AsyncMock + a prayer
import pytest
from unittest.mock import AsyncMock, patch

@pytest.mark.asyncio
async def test_analyze():
    with patch("httpx.AsyncClient.get",
               new_callable=AsyncMock) as m:
        m.return_value.json.return_value = {...}
        result = await analyze("a", 1)
        assert result.files_changed == 3