# integrations/langgraph/langgraph_memanto/nodes.py:39-49 (verbatim)
def _do_setup(resolved_agent_id: str):
    try:
        client.create_agent(agent_id=resolved_agent_id, pattern="tool")
    except Exception:
        pass
    try:
        result = client.activate_agent(resolved_agent_id, duration_hours=6)
        client.session_token = result.get("session_token")     # ← mutates the
                                                               #   process-wide
                                                               #   shared client
    except Exception:
        pass

import asyncio
import uuid


class SdkClient:
    """Mirrors the real client: single instance per process, session_token
    is a mutable instance attribute."""

    def __init__(self):
        self.session_token = None

    def create_agent(self, *, agent_id, pattern):
        pass

    async def activate_agent(self, agent_id, duration_hours=6):
        await asyncio.sleep(0.05)
        return {"session_token": f"TOKEN_{agent_id}_{uuid.uuid4().hex[:6]}"}

    async def recall(self, *, agent_id, query):
        await asyncio.sleep(0.02)
        if self.session_token is None:
            raise Exception("no active session")
        # Model the silent-leak case: the API authenticates by token,
        # returns whichever agent the token belongs to (regardless of
        # the agent_id the caller asked for).
        token_agent_id = self.session_token.split("_")[1]
        return {
            "memories": [
                {
                    "title": f"Memory of {token_agent_id}",
                    "content": f"Private data of agent {token_agent_id}",
                }
            ],
            "served_for_agent_id": token_agent_id,
            "requested_agent_id": agent_id,
        }


def create_recall_node(client):
    async def _do_setup(resolved_agent_id):
        try:
            client.create_agent(agent_id=resolved_agent_id, pattern="tool")
        except Exception:
            pass
        try:
            result = await client.activate_agent(resolved_agent_id, duration_hours=6)
            client.session_token = result.get("session_token")
        except Exception:
            pass

    async def recall_node(state, config=None):
        resolved_agent_id = (config or {}).get("configurable", {}).get("agent_id")
        try:
            result = await client.recall(agent_id=resolved_agent_id, query=state["query"])
        except Exception:
            await _do_setup(resolved_agent_id)
            result = await client.recall(agent_id=resolved_agent_id, query=state["query"])
        return {"recalled": result, "agent_id_in_request": resolved_agent_id}

    return recall_node


async def main():
    shared_client = SdkClient()
    recall_node = create_recall_node(shared_client)
    users = ["alice", "bob", "carol", "dave"]
    results = await asyncio.gather(*[
        recall_node({"query": "what is my favourite colour?"},
                    {"configurable": {"agent_id": uid}})
        for uid in users
    ])
    for r in results:
        req = r["agent_id_in_request"]
        served = r["recalled"]["served_for_agent_id"]
        marker = "OK" if req == served else "*** LEAK ***"
        print(f"user={req:<6}  served_for={served:<8}  {marker}")


asyncio.run(main())