Add adk/a2a support

Signed-off-by: David Gageot <[email protected]>

Author: dgageot

cmd/root/adk.go

@@ -0,0 +1,53 @@
+package root
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/docker/cagent/pkg/adk"
+	"github.com/docker/cagent/pkg/cli"
+	"github.com/docker/cagent/pkg/config"
+	"github.com/docker/cagent/pkg/telemetry"
+)
+
+type adkFlags struct {
+	agentName  string
+	workingDir string
+	port       int
+	runConfig  config.RuntimeConfig
+}
+
+func newADKCmd() *cobra.Command {
+	var flags adkFlags
+
+	cmd := &cobra.Command{
+		Use:   "adk <agent-file>",
+		Short: "Start an ADK (Agent Development Kit) A2A server",
+		Long:  `Start an A2A (Agent-to-Agent) server that exposes cagent agents using Google's ADK framework`,
+		Example: `  cagent adk ./agent.yaml
+  cagent adk ./team.yaml --port 8080
+  cagent adk agentcatalog/pirate --port 9000`,
+		Args: cobra.ExactArgs(1),
+		RunE: flags.runADKCommand,
+	}
+
+	cmd.PersistentFlags().StringVarP(&flags.agentName, "agent", "a", "root", "Name of the agent to run")
+	cmd.PersistentFlags().StringVar(&flags.workingDir, "working-dir", "", "Set the working directory for the session (applies to tools and relative paths)")
+	cmd.PersistentFlags().IntVar(&flags.port, "port", 0, "Port to listen on (default: random available port)")
+	addRuntimeConfigFlags(cmd, &flags.runConfig)
+
+	return cmd
+}
+
+func (f *adkFlags) runADKCommand(cmd *cobra.Command, args []string) error {
+	telemetry.TrackCommand("adk", args)
+
+	ctx := cmd.Context()
+	out := cli.NewPrinter(cmd.OutOrStdout())
+	agentFilename := args[0]
+
+	if err := setupWorkingDirectory(f.workingDir); err != nil {
+		return err
+	}
+
+	return adk.StartA2AServer(ctx, out, agentFilename, f.agentName, f.runConfig, f.port)
+}

cmd/root/root.go

@@ -85,6 +85,7 @@ func NewRootCmd() *cobra.Command {
 	cmd.AddCommand(newAPICmd())
 	cmd.AddCommand(newACPCmd())
 	cmd.AddCommand(newMCPCmd())
+	cmd.AddCommand(newADKCmd())
 	cmd.AddCommand(newEvalCmd())
 	cmd.AddCommand(newPushCmd())
 	cmd.AddCommand(newPullCmd())

docs/adk-integration.md

@@ -0,0 +1,109 @@
+# CAgent ADK Integration
+
+This document describes the ADK (Agent Development Kit) integration for cagent, which enables exposing cagent agents via Google's A2A (Agent-to-Agent) protocol.
+
+## Overview
+
+The ADK integration allows cagent agents to be exposed as A2A servers, enabling agent-to-agent communication using Google's standardized protocol. This makes cagent agents interoperable with other ADK-based agents.
+
+## Components
+
+### 1. Package: `pkg/adk`
+
+This package contains the core integration code:
+
+- **`adapter.go`**: Wraps cagent agents as ADK agents
+  - `NewCAgentAdapter(team, agentName)`: Creates an ADK agent from a cagent agent
+  - Converts cagent runtime events to ADK session events
+  - Handles streaming responses and error propagation
+
+- **`server.go`**: A2A server implementation
+  - `StartA2AServer(team, agentName, port, out)`: Starts an A2A server
+  - Uses ADK's `a2asrv` package for the server implementation
+  - Provides agent card at `/.well-known/agent.json`
+
+### 2. Command: `cagent adk`
+
+Located in `cmd/root/adk.go`, this command starts an A2A server for a cagent agent.
+
+#### Usage
+
+```bash
+# Start A2A server for an agent
+cagent adk ./agent.yaml
+
+# Specify a custom port
+cagent adk ./agent.yaml --port 8080
+
+# Use an agent from the catalog
+cagent adk agentcatalog/pirate --port 9000
+```
+
+#### Features
+
+- Auto-selects available port if not specified
+- Loads agents from files or agent catalog
+- Supports all cagent features (tools, models gateway, etc.)
+- Provides agent metadata via standard A2A agent card
+
+## Architecture
+
+The integration works by:
+
+1. **Agent Wrapping**: Cagent agents are wrapped using ADK's `agent.New()` with a custom Run function
+2. **Event Conversion**: Cagent runtime events are converted to ADK session events:
+   - `AgentChoiceEvent` → LLM response events (with streaming support)
+   - `ErrorEvent` → Error propagation
+   - `StreamStoppedEvent` → Final complete event
+3. **A2A Server**: The ADK `a2asrv` package handles the HTTP server and A2A protocol
+
+## Event Flow
+
+```
+User Request
+    ↓
+ADK InvocationContext (contains user message)
+    ↓
+CAgent Session (created from user message)
+    ↓
+CAgent Runtime (executes agent logic)
+    ↓
+Runtime Events (streamed)
+    ↓
+ADK Session Events (converted)
+    ↓
+A2A Response (sent to client)
+```
+
+## Dependencies
+
+The integration requires:
+- `google.golang.org/adk` v0.1.0
+- `github.com/a2aproject/a2a-go` v0.3.0
+- Standard cagent dependencies
+
+## Limitations and Future Work
+
+1. **Tool Call Visibility**: Currently, tool calls are handled internally and not exposed as separate ADK events
+2. **Artifacts**: ADK artifact support not yet integrated
+3. **Memory**: ADK memory features not yet integrated
+4. **Sub-agents**: Cagent teams/multi-agent scenarios need further work
+5. **Callbacks**: ADK before/after agent callbacks not yet used
+
+## Testing
+
+Build and test:
+```bash
+# Build
+go build -o cagent .
+
+# Test
+./cagent adk --help
+```
+
+## Implementation Notes
+
+- The adapter uses ADK's custom agent API (`agent.New`) rather than implementing the full `Agent` interface
+- Events are yielded using Go 1.22's `iter.Seq2` pattern for streaming
+- The implementation focuses on single-agent scenarios; multi-agent support may need refinement
+- OAuth and other A2A features are handled by the ADK library