Content
# go-a2a: Golang Implementation of the A2A Protocol
This is a Golang implementation of the Agent-to-Agent (A2A) protocol, an open protocol enabling communication and interoperability between agentic applications.
## Features
- Complete implementation of the A2A JSON-RPC protocol
- Task management with proper state transitions
- Streaming support with Server-Sent Events (SSE)
- Push notification capabilities
- Support for agent discovery via agent cards
- Both client and server implementations
## Package Structure
- `pkg/types`: Core type definitions matching the A2A JSON schema
- `pkg/rpc`: JSON-RPC request/response handling
- `pkg/server`: A2A server implementation
- `pkg/client`: A2A client implementation
- `pkg/task`: Task management
- `pkg/stream`: Streaming capabilities
- `pkg/notification`: Push notification system
- `pkg/discovery`: Agent discovery (Agent Card handling)
- `examples`: Example implementations
## Getting Started
### Prerequisites
- Go 1.21 or higher
### Installation
```bash
go get github.com/thinkovation/go-a2a
```
### Running the Examples
To run the example server:
```bash
go run examples/simple_server.go
```
In another terminal, run the example client:
```bash
go run examples/simple_client.go
```
## Usage
### Creating a Server
```go
package main
import (
"github.com/thinkovation/go-a2a/pkg/discovery"
"github.com/thinkovation/go-a2a/pkg/server"
"github.com/thinkovation/go-a2a/pkg/types"
"net/http"
)
// Implement the TaskHandler interface
type MyTaskHandler struct{}
func (h *MyTaskHandler) ProcessTask(task *types.Task, message types.Message) error {
// Process the task and update its state
// ...
return nil
}
func main() {
// Create a task handler
taskHandler := &MyTaskHandler{}
// Create agent skills
skills := []types.AgentSkill{
{
ID: "example-skill",
Name: "Example Skill",
},
}
// Create agent capabilities
capabilities := types.AgentCapabilities{
Streaming: true,
PushNotifications: true,
StateTransitionHistory: true,
}
// Create the agent card
agentCard := discovery.GenerateAgentCard(
"My Agent",
"http://localhost:8080",
"1.0.0",
skills,
capabilities,
)
// Create the server configuration
config := server.ServerConfig{
AgentCard: *agentCard,
TaskHandler: taskHandler,
KeepHistory: true,
}
// Create and start the server
server := server.New(config)
http.ListenAndServe(":8080", server)
}
```
### Using the Client
```go
package main
import (
"fmt"
"github.com/thinkovation/go-a2a/pkg/client"
"github.com/thinkovation/go-a2a/pkg/types"
)
func main() {
// Create an A2A client
a2aClient := client.New("http://localhost:8080")
// Fetch the agent card
agentCard, err := a2aClient.FetchAgentCard()
if err != nil {
fmt.Printf("Error fetching agent card: %v\n", err)
return
}
// Create a message
message := types.Message{
Role: "user",
Parts: []types.Part{
{
Type: types.PartTypeText,
Text: new(string),
},
},
}
*message.Parts[0].Text = "Hello, agent!"
// Send the message to the agent
task, err := a2aClient.SendTask(message, nil, nil)
if err != nil {
fmt.Printf("Error sending message: %v\n", err)
return
}
fmt.Printf("Task created with ID: %s\n", task.ID)
}
```
## License
This project is licensed under the same license as the original A2A protocol specification.
## Acknowledgments
This implementation is based on the [A2A Protocol Specification](https://github.com/google/a2a).
