updating the repository with gemeini to have a running green agent and a docker image

Author: Samir-atra

README.md

@@ -1,87 +1,81 @@
-# A2A Agent Template
+# Code Translator Green Agent (Evaluator)
 
-A minimal template for building [A2A (Agent-to-Agent)](https://a2a-protocol.org/latest/) green agents compatible with the [AgentBeats](https://agentbeats.dev) platform.
+This repository contains the **Green Agent** for the Code Translator system. Built with the [Google Agent Development Kit (ADK)](https://google.github.io/adk-docs/), this agent acts as the evaluator and orchestrator for code translation scenarios.
 
-## Project Structure
+## Overview
 
-```
-src/
-├─ server.py      # Server setup and agent card configuration
-├─ executor.py    # A2A request handling
-├─ agent.py       # Your agent implementation goes here
-└─ messenger.py   # A2A messaging utilities
-tests/
-└─ test_agent.py  # Agent tests
-Dockerfile        # Docker configuration
-pyproject.toml    # Python dependencies
-.github/
-└─ workflows/
-   └─ test-and-publish.yml # CI workflow
-```
+The Green Agent is responsible for:
+1.  **Orchestrating** the interaction between participant agents (Purple Agents).
+2.  **Evaluating** the quality of code translations provided by participants.
+3.  **Scoring** the submissions based on specific criteria.
 
-## Getting Started
+### Evaluation Criteria
+The agent uses `gemini-2.5-flash` to judge translations based on:
+*   **Execution Correctness**: The code must run without errors.
+*   **Style & Documentation**: Adherence to the target language's style guides and proper commenting.
+*   **Conciseness**: Efficient code without unnecessary boilerplate.
+*   **Relevance**: Logical and structural equivalence to the original code.
 
-1. **Create your repository** - Click "Use this template" to create your own repository from this template
+## Architecture
 
-2. **Implement your agent** - Add your agent logic to [`src/agent.py`](src/agent.py)
+*   **Framework**: Google ADK (`google-adk[a2a]`)
+*   **Model**: Gemini 2.5 Flash
+*   **Communication**: Agent-to-Agent (A2A) Protocol
+*   **Server**: Uvicorn + FastAPI (exposed via ADK)
 
-3. **Configure your agent card** - Fill in your agent's metadata (name, skills, description) in [`src/server.py`](src/server.py)
+## Prerequisites
 
-4. **Write your tests** - Add custom tests for your agent in [`tests/test_agent.py`](tests/test_agent.py)
+*   Python 3.11+
+*   [uv](https://github.com/astral-sh/uv) (recommended) or pip
+*   Google GenAI API Key
 
-For a concrete example of implementing a green agent using this template, see this [draft PR](https://github.com/RDI-Foundation/green-agent-template/pull/3).
+## Setup & Installation
 
-## Running Locally
-
-```bash
-# Install dependencies
-uv sync
+1.  **Clone the repository:**
+    ```bash
+    git clone <repository-url>
+    cd code_translator_green_agent
+    ```
 
-# Run the server
-uv run src/server.py
-```
-
-## Running with Docker
-
-```bash
-# Build the image
-docker build -t my-agent .
+2.  **Configure Environment:**
+    Create a `.env` file in the root directory:
+    ```bash
+    GOOGLE_API_KEY=your_api_key_here
+    ```
 
-# Run the container
-docker run -p 9009:9009 my-agent
-```
+3.  **Install Dependencies:**
+    Using `uv`:
+    ```bash
+    uv sync
+    ```
 
-## Testing
+## Running the Agent
 
-Run A2A conformance tests against your agent.
+### Local Execution
+To run the agent server locally:
 
 ```bash
-# Install test dependencies
-uv sync --extra test
-
-# Start your agent (uv or docker; see above)
-
-# Run tests against your running agent URL
-uv run pytest --agent-url http://localhost:9009
+uv run src/server.py --host 0.0.0.0 --port 9009
 ```
 
-## Publishing
+The agent will be available at `http://localhost:9009`.
 
-The repository includes a GitHub Actions workflow that automatically builds, tests, and publishes a Docker image of your agent to GitHub Container Registry.
+### Docker Execution
+To build and run using Docker:
 
-If your agent needs API keys or other secrets, add them in Settings → Secrets and variables → Actions → Repository secrets. They'll be available as environment variables during CI tests.
+1.  **Build the image:**
+    ```bash
+    docker build -t code-translator-green .
+    ```
 
-- **Push to `main`** → publishes `latest` tag:
-```
-ghcr.io/<your-username>/<your-repo-name>:latest
-```
+2.  **Run the container:**
+    ```bash
+    docker run -p 9009:9009 --env-file .env code-translator-green
+    ```
 
-- **Create a git tag** (e.g. `git tag v1.0.0 && git push origin v1.0.0`) → publishes version tags:
-```
-ghcr.io/<your-username>/<your-repo-name>:1.0.0
-ghcr.io/<your-username>/<your-repo-name>:1
-```
-
-Once the workflow completes, find your Docker image in the Packages section (right sidebar of your repository). Configure the package visibility in package settings.
+## Project Structure
 
-> **Note:** Organization repositories may need package write permissions enabled manually (Settings → Actions → General). Version tags must follow [semantic versioning](https://semver.org/) (e.g., `v1.0.0`).
+*   `src/agent.py`: Defines the ADK Agent, system prompt, and evaluation logic.
+*   `src/server.py`: Entry point for the HTTP server.
+*   `src/tool_provider.py`: Tools for the agent (e.g., A2A communication).
+*   `src/common.py`: Shared data models (e.g., `TranslatorEval` schema).

pyproject.toml

@@ -1,18 +1,20 @@
 [project]
-name = "green-agent-template"
+name = "code-translator-green-agent"
 version = "0.1.0"
-description = "A template for A2A green agents"
-readme = "README.md"
-requires-python = ">=3.13"
+description = "Green Agent for Code Translator"
+requires-python = ">=3.11"
 dependencies = [
-    "a2a-sdk[http-server]>=0.3.20",
-    "pydantic>=2.12.5",
-    "uvicorn>=0.38.0",
+    "python-dotenv",
+    "uvicorn",
+    "httpx",
+    "google-genai",
+    "pydantic",
+    "google-adk[a2a]"
 ]
 
-[project.optional-dependencies]
-test = [
-    "pytest>=8.0.0",
-    "pytest-asyncio>=0.24.0",
-    "httpx>=0.28.1",
-]
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]

src/agent.py

@@ -1,75 +1,38 @@
-from typing import Any
-from pydantic import BaseModel, HttpUrl, ValidationError
-from a2a.server.tasks import TaskUpdater
-from a2a.types import Message, TaskState, Part, TextPart, DataPart
-from a2a.utils import get_message_text, new_agent_text_message
-
-from messenger import Messenger
-
-
-class EvalRequest(BaseModel):
-    """Request format sent by the AgentBeats platform to green agents."""
-    participants: dict[str, HttpUrl] # role -> agent URL
-    config: dict[str, Any]
-
-
-class Agent:
-    # Fill in: list of required participant roles, e.g. ["pro_debater", "con_debater"]
-    required_roles: list[str] = []
-    # Fill in: list of required config keys, e.g. ["topic", "num_rounds"]
-    required_config_keys: list[str] = []
-
-    def __init__(self):
-        self.messenger = Messenger()
-        # Initialize other state here
-
-    def validate_request(self, request: EvalRequest) -> tuple[bool, str]:
-        missing_roles = set(self.required_roles) - set(request.participants.keys())
-        if missing_roles:
-            return False, f"Missing roles: {missing_roles}"
-
-        missing_config_keys = set(self.required_config_keys) - set(request.config.keys())
-        if missing_config_keys:
-            return False, f"Missing config keys: {missing_config_keys}"
-
-        # Add additional request validation here
-
-        return True, "ok"
-
-    async def run(self, message: Message, updater: TaskUpdater) -> None:
-        """Implement your agent logic here.
-
-        Args:
-            message: The incoming message
-            updater: Report progress (update_status) and results (add_artifact)
-
-        Use self.messenger.talk_to_agent(message, url) to call other agents.
-        """
-        input_text = get_message_text(message)
-
-        try:
-            request: EvalRequest = EvalRequest.model_validate_json(input_text)
-            ok, msg = self.validate_request(request)
-            if not ok:
-                await updater.reject(new_agent_text_message(msg))
-                return
-        except ValidationError as e:
-            await updater.reject(new_agent_text_message(f"Invalid request: {e}"))
-            return
-
-        # Replace example code below with your agent logic
-        # Use request.participants to get participant agent URLs by role
-        # Use request.config for assessment parameters
-
-        await updater.update_status(
-            TaskState.working, new_agent_text_message("Thinking...")
-        )
-        await updater.add_artifact(
-            parts=[
-                Part(root=TextPart(text="The agent performed well.")),
-                Part(root=DataPart(data={
-                    # structured assessment results
-                }))
-            ],
-            name="Result",
-        )
+from google.adk.agents import Agent
+from google.adk.tools import FunctionTool
+from src.common import TranslatorEval
+from src.tool_provider import ToolProvider
+
+SYSTEM_PROMPT = '''
+you are an expert evaluation agent specialized in evaluating code and programming languages translation and 
+how efficient it is to run without errors, and judging a successful translation requires the following
+considerations:
+
+    - it does not produce error when it runs.
+    - it is styled and commented in the new language method.
+    - it is concise and does not have extra non relevant code.
+    - it is clear and relevant to the topic.
+
+the format of the output translation is as follows, containing at least two points of them with requirement for the first one:
+
+    1 - the translation: the translation of the code in the new language.
+    2 - it keeps the same functionality of the original code.
+    3 - it have the same structure and logic of the original code.
+
+the translation needs to start with a note about the current language and the new language.
+
+in general the translation needs to be clear, clean and error free.
+'''
+
+def create_judge_agent(tool_provider: ToolProvider) -> Agent:
+    return Agent(
+        name="translator_judge_adk",
+        model="gemini-2.5-flash",
+        description=(
+            "assess the quality of the programming language translation given and which one is better meeting the criteria"
+        ),
+        instruction=SYSTEM_PROMPT,
+        tools=[FunctionTool(func=tool_provider.talk_to_agent)],
+        output_schema=TranslatorEval,
+        after_agent_callback=lambda callback_context: tool_provider.reset()
+    )

src/client.py

@@ -0,0 +1,65 @@
+import httpx
+from uuid import uuid4
+from a2a.client import (
+    A2ACardResolver,
+    ClientConfig,
+    ClientFactory,
+    Consumer,
+)
+from a2a.types import (
+    Message,
+    Part,
+    Role,
+    TextPart,
+    DataPart,
+)
+
+DEFAULT_TIMEOUT = 300
+
+def create_message(*, role: Role = Role.user, text: str, context_id: str | None = None) -> Message:
+    return Message(
+        kind="message",
+        role=role,
+        parts=[Part(TextPart(kind="text", text=text))],
+        message_id=uuid4().hex,
+        context_id=context_id
+    )
+
+def merge_parts(parts: list[Part]) -> str:
+    chunks = []
+    for part in parts:
+        if isinstance(part.root, TextPart):
+            chunks.append(part.root.text)
+        elif isinstance(part.root, DataPart):
+            chunks.append(str(part.root.data))
+    return "\n".join(chunks)
+
+async def send_message(message: str, base_url: str, context_id: str | None = None, streaming=False, consumer: Consumer | None = None):
+    """Returns dict with context_id, response and status (if exists)"""
+    async with httpx.AsyncClient(timeout=DEFAULT_TIMEOUT) as httpx_client:
+        resolver = A2ACardResolver(httpx_client=httpx_client, base_url=base_url)
+        agent_card = await resolver.get_agent_card()
+        config = ClientConfig(
+            httpx_client=httpx_client,
+            streaming=streaming,
+        )
+        factory = ClientFactory(config)
+        client = factory.create(agent_card)
+        if consumer:
+            await client.add_event_consumer(consumer)
+
+        outbound_msg = create_message(text=message, context_id=context_id)
+        last_event = None
+        outputs = {
+            "response": "",
+            "context_id": None
+        }
+
+        async for event in client.send_message(outbound_msg):
+            last_event = event
+
+        if isinstance(last_event, Message):
+            outputs["context_id"] = last_event.context_id
+            outputs["response"] += merge_parts(last_event.parts)
+        
+        return outputs