agentmesh-p2p 0.1.0rc10__tar.gz

agentmesh_p2p-0.1.0rc10/.gitignore

@@ -0,0 +1,78 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+*.pyc
+
+# Test binary, built with `go test -c`
+*.test
+
+# Code coverage profiles and other test artifacts
+*.out
+coverage.*
+*.coverprofile
+profile.cov
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env
+
+# Editor/IDE
+# .idea/
+# .vscode/
+#
+bin/
+dist/
+# State of `make testnet` (database, router key, tokens)
+.agentmesh-one/
+# Stray binaries from `go build ./cmd/<name>/` in the repo root
+/agentmesh-node
+/agentmesh-one
+/agentmesh-box
+/agentmesh-router
+/agentmesh-console
+
+# Playwright console UI tests
+node_modules/
+tests/ui/playwright-report/
+tests/ui/test-results/
+/agentmesh-control-plane
+/agentmesh-bench
+/mcp-client
+/nano-init
+tests/e2e/logs/
+tests/integration/logs/
+tests/integration/scratch/
+__pycache__/
+.pytest_cache/
+.worktrees/
+.venv/
+*.egg-info/
+keys.db
+mobile/logcat.txt
+
+# Guest images built by scripts/build-rootfs.sh; gigabytes, and reproducible
+# from the script, so they belong in a bucket rather than in history.
+/rootfs.ext4
+/rootfs.tar
+
+# Android upload keystore and Firebase config: secrets, wherever they land.
+*.jks
+*.keystore
+key.properties
+google-services.json
+
+
+# Recordings of development/examples/sandboxed-agent/record.sh
+development/examples/sandboxed-agent/out/

agentmesh_p2p-0.1.0rc10/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.5
+Name: agentmesh-p2p
+Version: 0.1.0-rc.10
+Summary: Native SDK for joining an Agent Mesh from inside a Python agent process
+Project-URL: Homepage, https://github.com/google/agentmesh
+Project-URL: Source, https://github.com/google/agentmesh/tree/main/sdk/python
+License-Expression: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: anyio>=4
+Requires-Dist: biscuit-python>=0.4
+Requires-Dist: cryptography>=42
+Requires-Dist: h11>=0.14
+Requires-Dist: httpx>=0.27
+Requires-Dist: libp2p<0.9,>=0.8
+Requires-Dist: mcp<3,>=2
+Requires-Dist: multiaddr>=0.2
+Requires-Dist: protobuf<8,>=4.25
+Requires-Dist: trio>=0.26
+Provides-Extra: examples
+Requires-Dist: a2a-sdk[http-server]>=1.1; extra == 'examples'
+Requires-Dist: uvicorn>=0.30; extra == 'examples'
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# agentmesh-p2p (Python)
+
+Native Python SDK for joining an Agent Mesh from inside the agent
+process. It replaces the `agentmesh-node` sidecar for agents written in Python:
+the agent enrolls with the control plane, joins the mesh through a router,
+finds services and calls them, answers A2A requests for the agent itself,
+and follows the control plane's keys, bans and policy while it runs. It
+publishes no service; a tool or a model others should find by name runs
+behind a `agentmesh-node`. Import it as
+`agent_mesh`.
+
+Guide: [google.github.io/agentmesh/docs/guides/native-sdks](https://google.github.io/agentmesh/docs/guides/native-sdks/),
+from an empty machine to two programs on a mesh.
+Source: [github.com/google/agentmesh/tree/main/sdk/python](https://github.com/google/agentmesh/tree/main/sdk/python).
+
+## Install
+
+```bash
+pip install agentmesh-p2p
+```
+
+Python 3.11 or later. The SDK runs on trio (py-libp2p is trio-based); under
+asyncio, use it through `anyio` with the trio backend. One dependency,
+`fastecdsa`, builds from source against GMP (`libgmp-dev` on Debian).
+
+## Use
+
+Both programs below are in
+[`examples/`](https://github.com/google/agentmesh/tree/main/sdk/python/examples)
+and run against a real mesh in the repository's tests. They read the mesh
+from `AGENTMESH_CONTROL_PLANE_URL` and the enrollment token from
+`AGENTMESH_BOOTSTRAP_TOKEN_PATH`; the guide shows how to get both from `agentmesh-one`
+or from the operator of an existing mesh.
+
+Find a service and call it:
+
+<!-- embed: sdk/python/examples/call.py -->
+```python
+"""Calls something on the mesh: a tool of an MCP service or a path of an
+inference or A2A service someone published, found by name, or an agent that
+published nothing, reached by its peer ID.
+
+    python call.py mcp://everything echo '{"message": "hi"}'
+    python call.py inference://ollama /v1/models
+    python call.py 12D3KooW... a2a://agent /card
+
+AGENTMESH_CONTROL_PLANE_URL names the mesh. The first run enrolls with the file
+AGENTMESH_BOOTSTRAP_TOKEN_PATH (a token the mesh operator gave you) or AGENTMESH_JWT_PATH
+(a workload identity token your platform issues, such as a Kubernetes
+projected service account token), and keeps the identity and credential in
+AGENTMESH_STATE_DIR; later runs resume from there without it.
+"""
+
+import json
+import os
+import sys
+
+import trio
+from agent_mesh import AgentMesh
+
+argv = sys.argv[1:]
+# A first argument that is not a service target is the peer ID of an agent.
+peer_id = None
+if argv and "://" not in argv[0]:
+    peer_id, argv = argv[0], argv[1:]
+service = argv[0] if len(argv) > 0 else ("a2a://agent" if peer_id else "mcp://everything")
+tool_or_path = argv[1] if len(argv) > 1 else ("/card" if peer_id else "echo")
+args = json.loads(argv[2]) if len(argv) > 2 else {"message": "hi"}
+
+mesh = AgentMesh.enroll(
+    os.environ.get("AGENTMESH_CONTROL_PLANE_URL", "https://mesh.example.com"),
+    bootstrap_token_path=os.environ.get("AGENTMESH_BOOTSTRAP_TOKEN_PATH"),
+    jwt_path=os.environ.get("AGENTMESH_JWT_PATH"),
+    state_dir=os.environ.get("AGENTMESH_STATE_DIR", "~/.config/agentmesh/caller"),
+    # A plaintext http:// control plane is otherwise accepted only on loopback.
+    allow_insecure=os.environ.get("AGENTMESH_INSECURE_CONTROL_PLANE") == "true",
+)
+
+
+async def main() -> None:
+    async with mesh.join() as session:
+        print(f"on the mesh as {session.peer_id}")
+
+        if peer_id:
+            # An agent is not in the discovery table; the SDK finds the path
+            # to its peer ID through the routers.
+            await session.connect(peer_id)
+            provider = peer_id
+        else:
+            providers = await session.discover(service)
+            if not providers:
+                raise SystemExit(f"no member of the mesh serves {service}")
+            # A provider record can outlive its member; the first that answers is used.
+            for provider in providers:
+                try:
+                    await session.connect(provider)
+                    break
+                except (ConnectionError, PermissionError) as err:
+                    print(f"{provider.peer_id}: {err}", file=sys.stderr)
+            else:
+                raise SystemExit(f"no provider of {service} is reachable")
+        print(f"{service} is served by {peer_id or provider.peer_id}")
+
+        if service.startswith("mcp://"):
+            tools = await session.list_tools(provider, service)
+            print("tools:", ", ".join(t.name for t in tools))
+            result = await session.call_tool(provider, service, tool_or_path, args)
+            print("\n".join(result.text))
+        else:
+            response = await session.request(provider, service, tool_or_path)
+            print(response.status, response.text)
+
+
+trio.run(main)
+```
+<!-- /embed -->
+
+Be an agent others can call. Nothing is published; a caller reaches the
+agent by its peer ID, the one it prints, through a router:
+
+<!-- embed: sdk/python/examples/agent.py -->
+```python
+"""An agent on the mesh: joins, then answers A2A requests from other members
+until stopped. It publishes nothing. There is no service name to look up; a
+caller reaches the agent by its peer ID, through a router, as `a2a://agent`.
+The mesh policy decides which members may call; the SDK turns the others away
+before anything reaches this code.
+
+    python agent.py                        # answered by the handler below
+    python agent.py http://127.0.0.1:9999  # forwarded to an A2A server beside it
+
+AGENTMESH_CONTROL_PLANE_URL names the mesh. The first run enrolls with the file
+AGENTMESH_BOOTSTRAP_TOKEN_PATH (a token the mesh operator gave you) or AGENTMESH_JWT_PATH
+(a workload identity token your platform issues, such as a Kubernetes
+projected service account token), and keeps the identity and credential in
+AGENTMESH_STATE_DIR; later runs resume from there, as the same peer, without it.
+"""
+
+import json
+import os
+import sys
+
+import trio
+from agent_mesh import AgentMesh, HTTPRequest, HTTPResponse, VerifiedBiscuit
+
+backend_url = sys.argv[1] if len(sys.argv) > 1 else None
+
+mesh = AgentMesh.enroll(
+    os.environ.get("AGENTMESH_CONTROL_PLANE_URL", "https://mesh.example.com"),
+    bootstrap_token_path=os.environ.get("AGENTMESH_BOOTSTRAP_TOKEN_PATH"),
+    jwt_path=os.environ.get("AGENTMESH_JWT_PATH"),
+    state_dir=os.environ.get("AGENTMESH_STATE_DIR", "~/.config/agentmesh/agent"),
+    # A plaintext http:// control plane is otherwise accepted only on loopback.
+    allow_insecure=os.environ.get("AGENTMESH_INSECURE_CONTROL_PLANE") == "true",
+)
+
+
+async def card(request: HTTPRequest, caller: VerifiedBiscuit) -> HTTPResponse:
+    """Answers every path with who was asked and who asked; a real agent runs
+    an A2A server here, or beside this process at backend_url."""
+    body = json.dumps({"name": "agent", "path": request.path, "caller": caller.peer_id})
+    return HTTPResponse(status=200, headers={"content-type": "application/json"}, body=body.encode())
+
+
+async def main() -> None:
+    async with mesh.join() as session:
+        target = await session.accept_a2a(backend_url or card)
+        print(f"accepting {target} as {session.peer_id}", flush=True)
+        await trio.sleep_forever()
+
+
+trio.run(main)
+```
+<!-- /embed -->
+
+`enroll` reuses the identity and credential saved in `state_dir` when they
+are still valid for that control plane, and needs exactly one of
+`bootstrap_token_path`, `bootstrap_token`, `jwt_path` or `jwt` (a token string
+or a `Callable[[], str]` invoked at enrollment and on every refresh)
+otherwise. Read tokens from a file, a callback or the environment; do not put
+them on a command line. `labels` are attested at enrollment;
+`join(egress_require_labels=)` is the floor every peer the session calls must
+attest, all of it, held for the session.
+
+A plaintext `http://` control plane is accepted only on loopback. Pass
+`allow_insecure=True` for a network you trust.
+
+## License
+
+Apache-2.0. Issues and contributions at
+[github.com/google/agentmesh](https://github.com/google/agentmesh).

agentmesh_p2p-0.1.0rc10/README.md

@@ -0,0 +1,191 @@
+# agentmesh-p2p (Python)
+
+Native Python SDK for joining an Agent Mesh from inside the agent
+process. It replaces the `agentmesh-node` sidecar for agents written in Python:
+the agent enrolls with the control plane, joins the mesh through a router,
+finds services and calls them, answers A2A requests for the agent itself,
+and follows the control plane's keys, bans and policy while it runs. It
+publishes no service; a tool or a model others should find by name runs
+behind a `agentmesh-node`. Import it as
+`agent_mesh`.
+
+Guide: [google.github.io/agentmesh/docs/guides/native-sdks](https://google.github.io/agentmesh/docs/guides/native-sdks/),
+from an empty machine to two programs on a mesh.
+Source: [github.com/google/agentmesh/tree/main/sdk/python](https://github.com/google/agentmesh/tree/main/sdk/python).
+
+## Install
+
+```bash
+pip install agentmesh-p2p
+```
+
+Python 3.11 or later. The SDK runs on trio (py-libp2p is trio-based); under
+asyncio, use it through `anyio` with the trio backend. One dependency,
+`fastecdsa`, builds from source against GMP (`libgmp-dev` on Debian).
+
+## Use
+
+Both programs below are in
+[`examples/`](https://github.com/google/agentmesh/tree/main/sdk/python/examples)
+and run against a real mesh in the repository's tests. They read the mesh
+from `AGENTMESH_CONTROL_PLANE_URL` and the enrollment token from
+`AGENTMESH_BOOTSTRAP_TOKEN_PATH`; the guide shows how to get both from `agentmesh-one`
+or from the operator of an existing mesh.
+
+Find a service and call it:
+
+<!-- embed: sdk/python/examples/call.py -->
+```python
+"""Calls something on the mesh: a tool of an MCP service or a path of an
+inference or A2A service someone published, found by name, or an agent that
+published nothing, reached by its peer ID.
+
+    python call.py mcp://everything echo '{"message": "hi"}'
+    python call.py inference://ollama /v1/models
+    python call.py 12D3KooW... a2a://agent /card
+
+AGENTMESH_CONTROL_PLANE_URL names the mesh. The first run enrolls with the file
+AGENTMESH_BOOTSTRAP_TOKEN_PATH (a token the mesh operator gave you) or AGENTMESH_JWT_PATH
+(a workload identity token your platform issues, such as a Kubernetes
+projected service account token), and keeps the identity and credential in
+AGENTMESH_STATE_DIR; later runs resume from there without it.
+"""
+
+import json
+import os
+import sys
+
+import trio
+from agent_mesh import AgentMesh
+
+argv = sys.argv[1:]
+# A first argument that is not a service target is the peer ID of an agent.
+peer_id = None
+if argv and "://" not in argv[0]:
+    peer_id, argv = argv[0], argv[1:]
+service = argv[0] if len(argv) > 0 else ("a2a://agent" if peer_id else "mcp://everything")
+tool_or_path = argv[1] if len(argv) > 1 else ("/card" if peer_id else "echo")
+args = json.loads(argv[2]) if len(argv) > 2 else {"message": "hi"}
+
+mesh = AgentMesh.enroll(
+    os.environ.get("AGENTMESH_CONTROL_PLANE_URL", "https://mesh.example.com"),
+    bootstrap_token_path=os.environ.get("AGENTMESH_BOOTSTRAP_TOKEN_PATH"),
+    jwt_path=os.environ.get("AGENTMESH_JWT_PATH"),
+    state_dir=os.environ.get("AGENTMESH_STATE_DIR", "~/.config/agentmesh/caller"),
+    # A plaintext http:// control plane is otherwise accepted only on loopback.
+    allow_insecure=os.environ.get("AGENTMESH_INSECURE_CONTROL_PLANE") == "true",
+)
+
+
+async def main() -> None:
+    async with mesh.join() as session:
+        print(f"on the mesh as {session.peer_id}")
+
+        if peer_id:
+            # An agent is not in the discovery table; the SDK finds the path
+            # to its peer ID through the routers.
+            await session.connect(peer_id)
+            provider = peer_id
+        else:
+            providers = await session.discover(service)
+            if not providers:
+                raise SystemExit(f"no member of the mesh serves {service}")
+            # A provider record can outlive its member; the first that answers is used.
+            for provider in providers:
+                try:
+                    await session.connect(provider)
+                    break
+                except (ConnectionError, PermissionError) as err:
+                    print(f"{provider.peer_id}: {err}", file=sys.stderr)
+            else:
+                raise SystemExit(f"no provider of {service} is reachable")
+        print(f"{service} is served by {peer_id or provider.peer_id}")
+
+        if service.startswith("mcp://"):
+            tools = await session.list_tools(provider, service)
+            print("tools:", ", ".join(t.name for t in tools))
+            result = await session.call_tool(provider, service, tool_or_path, args)
+            print("\n".join(result.text))
+        else:
+            response = await session.request(provider, service, tool_or_path)
+            print(response.status, response.text)
+
+
+trio.run(main)
+```
+<!-- /embed -->
+
+Be an agent others can call. Nothing is published; a caller reaches the
+agent by its peer ID, the one it prints, through a router:
+
+<!-- embed: sdk/python/examples/agent.py -->
+```python
+"""An agent on the mesh: joins, then answers A2A requests from other members
+until stopped. It publishes nothing. There is no service name to look up; a
+caller reaches the agent by its peer ID, through a router, as `a2a://agent`.
+The mesh policy decides which members may call; the SDK turns the others away
+before anything reaches this code.
+
+    python agent.py                        # answered by the handler below
+    python agent.py http://127.0.0.1:9999  # forwarded to an A2A server beside it
+
+AGENTMESH_CONTROL_PLANE_URL names the mesh. The first run enrolls with the file
+AGENTMESH_BOOTSTRAP_TOKEN_PATH (a token the mesh operator gave you) or AGENTMESH_JWT_PATH
+(a workload identity token your platform issues, such as a Kubernetes
+projected service account token), and keeps the identity and credential in
+AGENTMESH_STATE_DIR; later runs resume from there, as the same peer, without it.
+"""
+
+import json
+import os
+import sys
+
+import trio
+from agent_mesh import AgentMesh, HTTPRequest, HTTPResponse, VerifiedBiscuit
+
+backend_url = sys.argv[1] if len(sys.argv) > 1 else None
+
+mesh = AgentMesh.enroll(
+    os.environ.get("AGENTMESH_CONTROL_PLANE_URL", "https://mesh.example.com"),
+    bootstrap_token_path=os.environ.get("AGENTMESH_BOOTSTRAP_TOKEN_PATH"),
+    jwt_path=os.environ.get("AGENTMESH_JWT_PATH"),
+    state_dir=os.environ.get("AGENTMESH_STATE_DIR", "~/.config/agentmesh/agent"),
+    # A plaintext http:// control plane is otherwise accepted only on loopback.
+    allow_insecure=os.environ.get("AGENTMESH_INSECURE_CONTROL_PLANE") == "true",
+)
+
+
+async def card(request: HTTPRequest, caller: VerifiedBiscuit) -> HTTPResponse:
+    """Answers every path with who was asked and who asked; a real agent runs
+    an A2A server here, or beside this process at backend_url."""
+    body = json.dumps({"name": "agent", "path": request.path, "caller": caller.peer_id})
+    return HTTPResponse(status=200, headers={"content-type": "application/json"}, body=body.encode())
+
+
+async def main() -> None:
+    async with mesh.join() as session:
+        target = await session.accept_a2a(backend_url or card)
+        print(f"accepting {target} as {session.peer_id}", flush=True)
+        await trio.sleep_forever()
+
+
+trio.run(main)
+```
+<!-- /embed -->
+
+`enroll` reuses the identity and credential saved in `state_dir` when they
+are still valid for that control plane, and needs exactly one of
+`bootstrap_token_path`, `bootstrap_token`, `jwt_path` or `jwt` (a token string
+or a `Callable[[], str]` invoked at enrollment and on every refresh)
+otherwise. Read tokens from a file, a callback or the environment; do not put
+them on a command line. `labels` are attested at enrollment;
+`join(egress_require_labels=)` is the floor every peer the session calls must
+attest, all of it, held for the session.
+
+A plaintext `http://` control plane is accepted only on loopback. Pass
+`allow_insecure=True` for a network you trust.
+
+## License
+
+Apache-2.0. Issues and contributions at
+[github.com/google/agentmesh](https://github.com/google/agentmesh).

agentmesh_p2p-0.1.0rc10/examples/a2a_agent.py

@@ -0,0 +1,92 @@
+"""An agent written with the A2A SDK, on the mesh. The A2A SDK's server runs
+as it always does, a Starlette app under uvicorn on a loopback port; the mesh
+SDK accepts requests for a2a://agent and forwards them to it. Other members
+reach the agent by peer ID through a router; the mesh policy decides which
+ones, and the SDK turns the rest away before a request reaches the app.
+
+    python a2a_agent.py
+
+AGENTMESH_CONTROL_PLANE_URL names the mesh. The first run enrolls with the file
+AGENTMESH_BOOTSTRAP_TOKEN_PATH (a token the mesh operator gave you) or AGENTMESH_JWT_PATH
+(a workload identity token your platform issues, such as a Kubernetes
+projected service account token), and keeps the identity and credential in
+AGENTMESH_STATE_DIR; later runs resume from there, as the same peer, without it.
+"""
+
+import os
+import socket
+import threading
+
+import trio
+import uvicorn
+from a2a.helpers import get_message_text, new_text_message
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.types import AgentCapabilities, AgentCard, AgentInterface, AgentSkill, Role
+from agent_mesh import AgentMesh, MeshSession
+from starlette.applications import Starlette
+
+mesh = AgentMesh.enroll(
+    os.environ.get("AGENTMESH_CONTROL_PLANE_URL", "https://mesh.example.com"),
+    bootstrap_token_path=os.environ.get("AGENTMESH_BOOTSTRAP_TOKEN_PATH"),
+    jwt_path=os.environ.get("AGENTMESH_JWT_PATH"),
+    state_dir=os.environ.get("AGENTMESH_STATE_DIR", "~/.config/agentmesh/a2a-agent"),
+    # A plaintext http:// control plane is otherwise accepted only on loopback.
+    allow_insecure=os.environ.get("AGENTMESH_INSECURE_CONTROL_PLANE") == "true",
+)
+
+
+class EchoExecutor(AgentExecutor):
+    """One message in, one message out. X-Peer-Id is the caller the mesh
+    verified; the SDK sets it after authorizing the request."""
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        caller = context.call_context.state["headers"].get("x-peer-id", "someone") if context.call_context else "someone"
+        said = get_message_text(context.message) if context.message else ""
+        await event_queue.enqueue_event(new_text_message(f"{caller} said: {said}", role=Role.ROLE_AGENT, context_id=context.context_id))
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
+        pass
+
+
+def a2a_app(agent_url: str) -> Starlette:
+    """The A2A SDK's server, as its samples build it. The card names the agent
+    as the mesh reaches it: http://mesh/mesh/<peer-id>/a2a/agent."""
+    card = AgentCard(
+        name="Echo agent",
+        description="Answers every message with what it said and who sent it.",
+        version="1.0.0",
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        capabilities=AgentCapabilities(streaming=True),
+        supported_interfaces=[AgentInterface(protocol_binding="JSONRPC", url=agent_url, protocol_version="1.0")],
+        skills=[AgentSkill(id="echo", name="Echo", description="Repeats the message.", tags=["echo"], examples=["hello"])],
+    )
+    handler = DefaultRequestHandler(agent_executor=EchoExecutor(), task_store=InMemoryTaskStore(), agent_card=card)
+    return Starlette(routes=[*create_agent_card_routes(card), *create_jsonrpc_routes(handler, "/")])
+
+
+def serve_locally(app: Starlette) -> str:
+    """Runs uvicorn on a free loopback port in a thread and returns its URL.
+    The A2A SDK runs on asyncio, the mesh SDK on trio; a thread keeps them apart."""
+    with socket.socket() as probe:
+        probe.bind(("127.0.0.1", 0))
+        port = probe.getsockname()[1]
+    server = uvicorn.Server(uvicorn.Config(app, host="127.0.0.1", port=port, log_level="warning"))
+    threading.Thread(target=server.run, daemon=True).start()
+    return f"http://127.0.0.1:{port}"
+
+
+async def main() -> None:
+    backend_url = serve_locally(a2a_app(MeshSession.mesh_url(mesh.identity.peer_id, "a2a://agent")))
+    async with mesh.join() as session:
+        target = await session.accept_a2a(backend_url)
+        print(f"accepting {target} as {session.peer_id}", flush=True)
+        print(f"agent card at {session.agent_url}/.well-known/agent-card.json", flush=True)
+        await trio.sleep_forever()
+
+
+trio.run(main)

agentmesh_p2p-0.1.0rc10/examples/a2a_call.py

@@ -0,0 +1,60 @@
+"""Talks to an agent on the mesh with the A2A SDK's client. The mesh SDK is an
+httpx transport; the A2A client fetches the agent card and sends messages as
+it would to any A2A server, and every request travels to the peer through a
+router with this member's credential.
+
+    python a2a_call.py 12D3KooW... "hello"
+
+AGENTMESH_CONTROL_PLANE_URL names the mesh. The first run enrolls with the file
+AGENTMESH_BOOTSTRAP_TOKEN_PATH (a token the mesh operator gave you) or AGENTMESH_JWT_PATH
+(a workload identity token your platform issues, such as a Kubernetes
+projected service account token), and keeps the identity and credential in
+AGENTMESH_STATE_DIR; later runs resume from there without it.
+"""
+
+import os
+import sys
+
+import httpx
+import trio
+from a2a.client import A2ACardResolver, ClientConfig, create_client
+from a2a.helpers import get_message_text, new_text_message
+from a2a.types import Role, SendMessageRequest
+from agent_mesh import AgentMesh, MeshSession, MeshTransport
+
+if len(sys.argv) < 2:
+    raise SystemExit("usage: a2a_call.py <peer-id> [text]")
+peer_id = sys.argv[1]
+text = sys.argv[2] if len(sys.argv) > 2 else "hello"
+
+mesh = AgentMesh.enroll(
+    os.environ.get("AGENTMESH_CONTROL_PLANE_URL", "https://mesh.example.com"),
+    bootstrap_token_path=os.environ.get("AGENTMESH_BOOTSTRAP_TOKEN_PATH"),
+    jwt_path=os.environ.get("AGENTMESH_JWT_PATH"),
+    state_dir=os.environ.get("AGENTMESH_STATE_DIR", "~/.config/agentmesh/a2a-caller"),
+    # A plaintext http:// control plane is otherwise accepted only on loopback.
+    allow_insecure=os.environ.get("AGENTMESH_INSECURE_CONTROL_PLANE") == "true",
+)
+
+
+async def main() -> None:
+    async with mesh.join() as session:
+        print(f"on the mesh as {session.peer_id}")
+
+        # The agent's URL on the mesh, and an httpx client that carries requests to it.
+        agent_url = MeshSession.mesh_url(peer_id, "a2a://agent")
+        async with httpx.AsyncClient(transport=MeshTransport(session), timeout=60) as http:
+            card = await A2ACardResolver(http, agent_url).get_agent_card()
+            print(f"agent: {card.name}, {card.description}")
+
+            client = await create_client(card, ClientConfig(httpx_client=http, streaming=False))
+            request = SendMessageRequest(message=new_text_message(text, role=Role.ROLE_USER))
+            async for response in client.send_message(request):
+                if response.HasField("message"):
+                    print(get_message_text(response.message))
+                elif response.HasField("task") and response.task.status.HasField("message"):
+                    print(get_message_text(response.task.status.message))
+            await client.close()
+
+
+trio.run(main)