Stream and approve

pip install "10xgraph[google-genai]"
export GOOGLE_API_KEY=your-api-key

import asyncio

from tenxgraph.core.graph import Agent, StateGraph, ToolNode
from tenxgraph.core.state import AgentState, Message, StreamEvent
from tenxgraph.storage.checkpointer import InMemoryCheckpointer
from tenxgraph.utils import END, interrupt


def check_balance() -> str:
    """Check the account balance."""
    return "Current balance: $50,000"


def transfer_funds(amount: float, recipient: str) -> str:
    """Transfer funds to a recipient. Asks a human to approve first."""
    # First run: this call stops the graph.
    # Resumed run: it returns the value passed as {"resume": ...}.
    decision = interrupt(
        {"amount": amount, "recipient": recipient},
        message=f"Approve transfer of ${amount} to {recipient}?",
        reason="transfer_approval",
    )
    if not decision or not decision.get("approved"):
        return "Transfer cancelled by user"
    return f"Transferred ${amount} to {recipient}"


tool_node = ToolNode([check_balance, transfer_funds])

agent = Agent(
    model="gemini-2.5-flash",
    system_prompt=[
        {
            "role": "system",
            "content": (
                "You are a helpful financial advisor. Help users check their balance "
                "and transfer funds when requested."
            ),
        }
    ],
    tool_node=tool_node,
)


def should_use_tools(state: AgentState) -> str:
    """Route to TOOL when the assistant asked for tools, back to MAIN after a result."""
    if not state.context:
        return END

    last_message = state.context[-1]

    if last_message.role == "assistant" and last_message.tools_calls:
        return "TOOL"

    if last_message.role == "tool":
        return "MAIN"

    return END


graph = StateGraph(AgentState)
graph.add_node("MAIN", agent)
graph.add_node("TOOL", tool_node)
graph.add_conditional_edges("MAIN", should_use_tools, {"TOOL": "TOOL", END: END})
graph.add_edge("TOOL", "MAIN")
graph.set_entry_point("MAIN")

# A pause is saved in the checkpointer, so one is required to resume.
app = graph.compile(checkpointer=InMemoryCheckpointer())

async def run_until_pause(thread_id: str) -> dict | None:
    """Stream the first run. Return the interrupt request, or None if none was raised."""
    request = None
    async for chunk in app.astream(
        {"messages": [Message.text_message("Transfer $5,000 to Alice")]},
        config={"thread_id": thread_id},
    ):
        if chunk.event == StreamEvent.MESSAGE and chunk.message:
            if chunk.message.role == "assistant" and chunk.message.text():
                print(f"Assistant: {chunk.message.text()}")
        elif chunk.event == StreamEvent.UPDATES and chunk.data.get("status") == "interrupted":
            request = chunk.data["interrupt"]
    return request

async def resume_with(thread_id: str, decision: dict) -> None:
    """Resume the paused thread and stream the rest of the run."""
    async for chunk in app.astream(
        {"resume": decision},
        config={"thread_id": thread_id},
    ):
        if chunk.event == StreamEvent.MESSAGE and chunk.message:
            if chunk.message.role == "assistant" and chunk.message.text():
                print(f"Assistant: {chunk.message.text()}")


async def main() -> None:
    thread_id = "approval-demo-1"

    print("=== Streaming until approval is needed ===")
    request = await run_until_pause(thread_id)

    if request is None:
        print("The agent finished without asking for approval.")
        return

    print(f"\nPaused: {request['message']}")
    print(f"Details: {request['value']}")

    # In a real app a person answers here. This tutorial approves automatically.
    print("\n=== Resuming with approval ===")
    await resume_with(thread_id, {"approved": True})


if __name__ == "__main__":
    asyncio.run(main())

python approve_agent.py

=== Streaming until approval is needed ===
Assistant: I'll set up that transfer for you.

Paused: Approve transfer of $5000.0 to Alice?
Details: {'amount': 5000.0, 'recipient': 'Alice'}

=== Resuming with approval ===
Assistant: The transfer of $5,000 to Alice is complete.