Agent templates, HarnessAgent, and PROGRAM.md setup

agent/templates/
├── tau_bench.py           # tau-bench agent starting point
├── terminal_bench.py      # Terminal-Bench 2.0 agent starting point
└── bird_interact.py       # BIRD-Interact system agent starting point

program_templates/
├── base.md                # shared loop instructions (benchmark-agnostic)
├── tau_bench.md           # tau-bench supplement
├── terminal_bench.md      # Terminal-Bench supplement
└── bird_interact.md       # BIRD-Interact supplement

def copy_agent_template(benchmark: str) -> None:
    """Copy the correct agent template into agent/agent.py."""
    templates = {
        "tau-bench": "agent/templates/tau_bench.py",
        "terminal-bench": "agent/templates/terminal_bench.py",
        "bird-interact": "agent/templates/bird_interact.py",
    }
    template = templates.get(benchmark)
    if not template or not os.path.exists(template):
        print(f"[prepare] ERROR: no agent template for benchmark '{benchmark}'")
        sys.exit(1)

    shutil.copy2(template, "agent/agent.py")
    print(f"[prepare] copied {template} → agent/agent.py")

def copy_program_template(benchmark: str) -> None:
    """Compose PROGRAM.md from the shared base and the benchmark-specific section."""
    templates = {
        "tau-bench": "program_templates/tau_bench.md",
        "terminal-bench": "program_templates/terminal_bench.md",
        "bird-interact": "program_templates/bird_interact.md",
    }
    template = templates.get(benchmark)
    # ...
    with open("program_templates/base.md") as f:
        base = f.read()
    with open(template) as f:
        benchmark_content = f.read()

    with open("PROGRAM.md", "w") as f:
        f.write(base.rstrip("\n") + "\n\n" + benchmark_content)
    print(f"[prepare] composed PROGRAM.md from program_templates/base.md + {template}")

from tau2.agent.llm_agent import LLMAgent
from tau2.data_model.message import AssistantMessage, Message, MultiToolMessage, SystemMessage
from tau2.utils.llm_utils import generate

AGENT_MODEL: str = os.environ.get("AGENT_MODEL", "")

AGENT_INSTRUCTION = """
You are a helpful assistant that completes tasks according to the <policy> provided below.
""".strip()

@dataclass
class HarnessState:
    messages: list[Message] = field(default_factory=list)

class HarnessAgent(LLMAgent):
    """Agent under optimization."""

    @property
    def system_prompt(self) -> str:
        if self.domain_policy:
            return (
                "<instructions>\n"
                f"{AGENT_INSTRUCTION}\n"
                "</instructions>\n"
                "<policy>\n"
                f"{self.domain_policy}\n"
                "</policy>"
            )
        return AGENT_INSTRUCTION

    def get_init_state(
        self, message_history: list[Message] | None = None
    ) -> HarnessState:
        ...

    def generate_next_message(
        self,
        message: ValidAgentInputMessage,
        state: HarnessState,
    ) -> tuple[AssistantMessage, HarnessState]:
        ...

from harbor.agents.base import BaseAgent
from harbor.environments.base import BaseEnvironment
from harbor.models.agent.context import AgentContext

MAX_STEPS = 80
MAX_OUTPUT_CHARS = 8000
MODEL = os.environ.get("AGENT_MODEL", "gpt-5.4")

AGENT_INSTRUCTION = """\
You are an autonomous terminal agent. You are given a task and a Linux container.
You solve tasks by executing bash commands. Work step by step.
...
"""

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "bash",
            "description": "Execute a bash command in the container. Returns stdout and stderr.",
            ...
        },
    }
]

class HarnessAgent(BaseAgent):
    """Agent under optimization for Terminal-Bench 2.0."""

    @staticmethod
    def name() -> str:
        return "harness-agent"

    def version(self) -> str | None:
        return "0.1.0"

    async def setup(self, environment: BaseEnvironment) -> None:
        pass

    async def run(
        self,
        instruction: str,
        environment: BaseEnvironment,
        context: AgentContext,
    ) -> None:
        ...

from google.adk import Agent
from google.adk.tools import FunctionTool

AINTERACT_INSTRUCTION = """You are a helpful PostgreSQL agent that interacts with a user and a
database to solve the user's question..."""

CINTERACT_INSTRUCTION = """You are a data scientist with great PostgreSQL writing ability..."""

def build_agent(mode: str = "a-interact") -> Agent:
    """Build the BIRD-Interact system agent for the requested mode."""
    if mode == "a-interact":
        return Agent(
            **_agent_kwargs(),
            instruction=AINTERACT_INSTRUCTION,
            tools=get_ainteract_tools(),
            ...
        )
    # c-interact path
    return Agent(
        **_agent_kwargs(),
        instruction=CINTERACT_INSTRUCTION,
        tools=[FunctionTool(ask_user), FunctionTool(submit_sql)],
        ...
    )

program_templates/
├── base.md              # universal loop (never benchmark-specific)
├── tau_bench.md         # tau-bench supplement: task ID format, trace locations, editing guidance
├── terminal_bench.md    # Terminal-Bench supplement: trace paths, techniques, diff command
└── bird_interact.md     # BIRD-Interact supplement: modes, trace format, editing targets