Fasta2a

0.6.0 · active · verified Mon Apr 13

Fasta2a (current version 0.6.0) is a Python library that converts an AI Agent into an A2A (Agent-to-Agent) server. It facilitates communication between AI agents by implementing the A2A protocol, allowing agents to expose their capabilities and interact programmatically. The library is relatively new but actively developed, with releases occurring every few months as the protocol specification evolves.

Warnings

breaking The A2A protocol version support changes between `fasta2a` releases. For example, `v0.6.0` introduced support for `protocolVersion 0.3.0`. Older versions of `fasta2a` may not be compatible with newer protocol versions, and vice-versa, leading to parsing errors or unexpected agent behavior.
Fix: Always check the release notes for the supported A2A protocol version for your `fasta2a` library version. Upgrade `fasta2a` to match the desired protocol version, or ensure your client/agent adheres to the protocol version supported by your `fasta2a` server.
gotcha The core A2A schemas (`AgentMessage`, `AgentResponse`, `ToolCall`, `StreamMessageResponse`, etc.) are actively evolving as the protocol matures. Code relying on specific schema fields or structures might require updates with new `fasta2a` releases.
Fix: Regularly review the `fasta2a` changelog and schema definitions when upgrading. Be prepared to adapt your agent logic and data models to new schema versions to maintain compatibility.
gotcha Fasta2a applications are ASGI applications and must be run with a compatible ASGI server (e.g., `uvicorn`) to be accessible. Simply running the Python script will define the application object but will not serve it over HTTP.
Fix: To run your `fasta2a` application, use the command `uvicorn your_module_name:app --host 0.0.0.0 --port 8000` (replacing `your_module_name` with your script's filename). Do not attempt to run it directly as `python your_module_name.py`.

Install

pip install fasta2a Install fasta2a

Imports

Fasta2aApp
```
from fasta2a.app import Fasta2aApp
```
AgentMessage
```
from fasta2a.schema import AgentMessage
```

AgentResponse

from fasta2a.schema import AgentResponse

ToolCall
```
from fasta2a.schema import ToolCall
```

StreamMessageResponse

from fasta2a.schema import StreamMessageResponse

Quickstart

This quickstart demonstrates how to create a basic Fasta2a application by initializing `Fasta2aApp` and defining an asynchronous message handler using the `@app.handle_message()` decorator. The handler processes `AgentMessage` objects and returns `AgentResponse` objects, optionally including `ToolCall`s. The example also shows how to run the application using `uvicorn`.

import uvicorn
from fasta2a.app import Fasta2aApp
from fasta2a.schema import AgentMessage, AgentResponse, ToolCall

app = Fasta2aApp()

@app.handle_message()
async def my_agent_handler(message: AgentMessage) -> AgentResponse:
    """Handles incoming AgentMessage and returns an AgentResponse."""
    print(f"Received message: {message.body}")
    if message.body == "hello":
        return AgentResponse(body="world")
    elif message.body == "call_tool":
        return AgentResponse(
            body="I am calling a hypothetical tool!",
            toolCalls=[
                ToolCall(
                    name="my_example_tool",
                    arguments={"param1": "value1", "param2": 123}
                )
            ]
        )
    return AgentResponse(body=f"Unknown message: {message.body}")

# To run this application, save it as, e.g., `main.py`
# and execute from your terminal:
# uvicorn main:app --host 0.0.0.0 --port 8000
# Then you can interact with it using an A2A client.

view raw JSON →