Skip to content

make_peers_tool

autogen.beta.network.client.tools.peers.make_peers_tool #

make_peers_tool(agent_client)

Return a closure-bound peers tool.

Source code in autogen/beta/network/client/tools/peers.py 
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
def make_peers_tool(agent_client: "AgentClient") -> object:
    """Return a closure-bound ``peers`` tool."""

    @tool
    async def peers(
        action: Literal["find", "describe"],
        *,
        query: str | None = None,
        capability: str | None = None,
        sort_by: Literal["name", "cost", "track_record"] | None = None,
        name: str | None = None,
        limit: int = 20,
        client: AgentClientInject = None,
    ) -> list[dict] | dict | str:
        """Discover and describe peers.

        ``find``:    args query?, capability?, sort_by?, limit
        ``describe``: args name (or agent_id) → {passport, resume, skill_md}
        """
        actual = client if client is not None else agent_client
        hub = actual._hub_client
        if action == "find":
            passports = await hub.list_agents(capability=capability, query=query, limit=limit)
            results: list[dict] = []
            for p in passports:
                if p.agent_id == actual.agent_id:
                    continue  # don't include the calling agent
                resume = await hub.get_resume(p.agent_id)
                results.append(_passport_summary(p, resume))
            if sort_by == "name":
                results.sort(key=lambda r: r["name"])
            elif sort_by == "cost":
                results.sort(key=lambda r: (r["cost"] or {}).get("input_per_mtok") or float("inf"))
            elif sort_by == "track_record":
                results.sort(
                    key=lambda r: r["observed_success_rate"] or 0.0,
                    reverse=True,
                )
            return results

        if action == "describe":
            if not name:
                return "Error: describe requires `name` (or agent_id)"
            try:
                passport = await hub.get_agent(name)
            except Exception:
                return f"Error: peer {name!r} not found"
            assert passport.agent_id is not None
            resume = await hub.get_resume(passport.agent_id)
            skill_md = await hub.get_skill(passport.agent_id)
            if not skill_md:
                skill_md = render_fallback_skill(passport, resume)
            return {
                "passport": {
                    "name": passport.name,
                    "agent_id": passport.agent_id,
                    "owner": passport.owner,
                    "provider": passport.provider,
                    "model": passport.model,
                },
                "resume": {
                    "summary": resume.summary,
                    "claimed_capabilities": list(resume.claimed_capabilities),
                    "domains": list(resume.domains),
                    "observed": {
                        cap: {
                            "n": s.n,
                            "completed": s.completed,
                            "failed": s.failed,
                            "expired": s.expired,
                        }
                        for cap, s in resume.observed.items()
                    },
                },
                "skill_md": skill_md,
            }

        return f"Error: unknown action {action!r}; choose from find, describe"

    return peers