Role-Play

Implement the Role-Play pattern in this codebase, using the LLM client and language we already use.

## Goal

Complete a task through a conversation between two role-prompted agents, an AI user that gives one instruction at a time and an AI assistant that carries each one out, after a specifier turns the rough idea into a concrete task.

## How it works

1. Call the model with the Task specifier prompt, passing the rough idea and both role names, to get a specific, concrete task.
2. Build the AI user's system prompt from the AI user (instructor) prompt and the AI assistant's from the AI assistant (doer) prompt, each with both role names and the specified task. Keep a separate message history for each agent.
3. Ask the AI user for its first instruction. Pass each instruction to the AI assistant as a user message, and pass each solution back to the AI user the same way.
4. Check the format of every reply: the AI user must start with 'Instruction:' or send the done token, and the AI assistant must start with 'Solution:'. On a mismatch, resend that agent's role rules and ask again, once.
5. When the AI user's message contains <CAMEL_TASK_DONE>, return the specified task, the full transcript and the assistant's solutions in order.

## Prompts

### Task specifier prompt

```markdown
Here is a task that {{assistant_role}} will help {{user_role}} to complete:
<idea>{{idea}}</idea>

Make it more specific: name the concrete deliverable, the inputs it works on
and how we will know it is finished. Be creative but realistic.
Reply with the specified task only, in {{word_limit}} words or fewer.
```

### AI user (instructor) prompt

```markdown
Never forget you are a {{user_role}} and I am a {{assistant_role}}. Never flip roles!
We share a common interest in completing this task: {{task}}

You must instruct me, one instruction at a time, to complete the task.
Always reply in this form:
Instruction: <one concrete instruction>
Input: <the input it needs, or None>

Give instructions only, never solutions. Do not ask me questions.
When the task is fully complete, reply with only: <CAMEL_TASK_DONE>
Never say <CAMEL_TASK_DONE> unless my responses have solved the task.
```

### AI assistant (doer) prompt

```markdown
Never forget you are a {{assistant_role}} and I am a {{user_role}}. Never flip roles!
We share a common interest in completing this task: {{task}}

I will give you one instruction at a time. Carry out each one with a
specific, complete solution. If you cannot, say why and decline.
Always reply in this form:
Solution: <your solution, with any code or detail it needs>
Next request.

Never give me instructions, and never ask me questions.
```

## Stop rule

Stop when the AI user sends <CAMEL_TASK_DONE>, or after 20 instruction and solution rounds. On the cap, return the transcript with a status of max_rounds. If one agent repeats the same message three times, stop early with a status of looping.

## Requirements

- Never let the roles flip: the AI user only instructs and the AI assistant only solves. Treat a reply in the wrong role as a format error.
- Make the round cap a parameter (default 20), and detect three identical consecutive messages from either agent as a loop.
- The two agents may use different models, configured separately; the specifier can be a cheaper model.
- Log every message with its role, its round number and its token count.
- Add a test with a stub LLM whose AI user replies 'Instruction: a', 'Instruction: b', then <CAMEL_TASK_DONE>, and whose AI assistant always replies 'Solution: ... Next request.'; assert exactly two AI assistant calls and a transcript ordered instruction, solution, instruction, solution, done.