Publish NeMo Gym conversational tool-use assets

README.md

@@ -5,21 +5,23 @@ pretty_name: NeMo Gym Conversational Tool-Use Assets
 
 # NeMo Gym Conversational Tool-Use Assets
 
-This dataset repository stores the non-code assets used by NeMo Gym's conversational tool-use generation pipeline.
-It is an asset bundle for Gym components, not a training or evaluation dataset.
+This dataset repository stores the prompts and reference assets used by NeMo Gym's conversational tool-use generation
+and simulation pipeline. It is an asset bundle for Gym components, not a training or evaluation dataset.
 
 ## Contents
 
-- `conversational_tool_use_policy_tool_generation/golden_policies`: eight policy/tool reference pairs required by
-  the `conversational_tool_use_policy_tool_generation` agent.
-- `conversational_tool_use_policy_tool_generation/prompt_history`: historical policy/tool-generation prompt
-  revisions, retained for inspection but not required at runtime.
-- `conversational_tool_use_domain_generation/prompt_history`: historical domain-generation prompt revisions,
-  retained for inspection but not required at runtime.
+- `conversational_tool_use_domain_generation/prompts`: domain generation and follow-up prompts.
+- `conversational_tool_use_domain_generation/prompt_history`: historical domain-generation prompt revisions.
+- `conversational_tool_use_policy_tool_generation/prompts`: policy, tool, refinement, and judge prompts.
+- `conversational_tool_use_policy_tool_generation/golden_policies`: eight policy/tool reference pairs used in prompts.
+- `conversational_tool_use_policy_tool_generation/prompt_history`: historical policy/tool-generation prompt revisions.
+- `conversational_tool_use_scenario_generation/prompts`: scenario-generation system and user prompts.
+- `conversational_tool_use_agent/prompts`: policy-agent system prompts for serial and parallel tool calls.
+- `conversational_tool_use_simulation/prompts`: user simulator, tool simulator, and verifier prompt templates.
 
-The active prompt templates remain in the NeMo Gym source tree because they define current agent behavior. Run the
-policy/tool-generation agent's preparation command to download and checksum-validate its runtime references:
+Run the conversational tool-use simulation resource server's preparation command once per checkout to download and
+checksum-validate all runtime prompts and references:
 
 ```bash
-python -m responses_api_agents.conversational_tool_use.policy_tool_generation.prepare
+python -m resources_servers.conversational_tool_use_simulation.prepare
 ```

conversational_tool_use_agent/prompts/agent_parallel_system.txt

@@ -0,0 +1,12 @@
+You are a customer service agent that helps the user.  The policy that determines how you should respond to requests from users is described below between the <policy> and </policy> tags.
+
+In each turn you can either:
+- Send a message to the user.
+- Make one or more tool calls.
+You cannot do both at the same time.
+
+<policy>
+{domain_policy}
+</policy>
+
+Try to be helpful and always follow the policy.

conversational_tool_use_agent/prompts/agent_system.txt

@@ -0,0 +1,12 @@
+You are a customer service agent that helps the user.  The policy that determines how you should respond to requests from users is described below between the <policy> and </policy> tags.
+
+In each turn you can either:
+- Send a message to the user.
+- Make a tool call.
+You cannot do both at the same time.
+
+<policy>
+{domain_policy}
+</policy>
+
+Try to be helpful and always follow the policy.

conversational_tool_use_domain_generation/prompts/domain_followup.txt

@@ -0,0 +1 @@
+Do not repeat these domains. Try looking for other domains or find specific sub-domains.

conversational_tool_use_domain_generation/prompts/domain_generation.txt

@@ -0,0 +1,20 @@
+Please give me list of all business/industry sectors that may benefit from having a customer-facing internet chatbot agent helper.
+Imagine that the chatbot will have a set of executable tools that interface with a system to help the customer's needs.
+Please generate at least 50 domains.
+
+
+Please format your response as a JSON such as:
+```json
+[
+    {
+        "name": <name of item>,
+        "applications": [
+            {
+                "function": <name of functionality the chatbot can have that can help the user>
+            },
+            ...
+        ]
+    },
+    ...
+]
+```

conversational_tool_use_policy_tool_generation/prompts/cohesion_judge.txt

@@ -0,0 +1,28 @@
+Your job is to judge the policy.md and tools.jsonl for an automated agent for the {domain} domain.
+Specifically, you must make a judgment about how consistent and cohesive the policy and tools are to each other.
+
+Setting:
+1. policy.md
+    - The policy is what the automated chatbot agent bases their actions upon. It includes the background, the tools provided to the agent, and the constraints for the actions.
+2. tools.jsonl
+    - The list of tools that the agent can use to interact with the underlying system to address the customer's needs. Each tool contains a full json specification for the usage / inputs / outputs of each tool.
+
+Your task is as follows:
+1. Carefully read the policy.md and tools.jsonl and understand their usage.
+2. Check for inconsistencies:
+    - If there are references to tools in the policy that are not in the tools list.
+    - If there are tools in the tools list that are not referred to in the policy.
+    - If the description of the tool is consistent with its counterpart in the policy.
+3. Check for cohesion:
+    - Even if the policy and tools are consistent to each other, they must have synergy. If the contents of the tools and the policy may cause confusion for the automated agent, there is low cohesion and the policy / tools are not a good match for each other.
+4. Write your judgment between <judgment> </judgment> tags. Write 'true' if the policy.md and tools.jsonl is consistent and cohesive to each other, or 'false' if not.
+
+Make sure to deliberate deeply and provide resoning before providing a judgment.
+
+<policy.md>
+{policy}
+</policy.md>
+
+<tools.jsonl>
+{tools}
+</tools.jsonl>

conversational_tool_use_policy_tool_generation/prompts/general_policy.txt

@@ -0,0 +1,38 @@
+Your job is to generate the policy.md file for an automated agent for the {domain} domain. 
+Specifically, you will be writing the policy for an automated chatbot agent that a customer to a business in the {domain} domain can interact with.
+A reference policy and tools is provided to help show an example output for the task.
+
+Your task is as follows:
+1. Think about the {domain} domain and consider businesses that can span from that domain.
+2. Choose a specific business that can benefit from deploying a chatbot agent that the business' customers can interact with for business-related tasks.
+3. Deliberate about the tools that the chatbot agent can use to interact with an underlying system to resolve a customer's needs. Your tools can be in camel case or snake case. Think of at least 10 tools that can be used by the policy.
+4. Create a policy.md file for the chatbot agent between <policy> </policy> tags.
+
+When writing the policy, consider:
+- Include the current time in the policy the model can refer to, which is {timestamp}.
+- Add a statement to avoid answering questions that the chatbot isn’t qualified to handle—especially those that require advice not based on the policy.
+- Always include a way for the agent to escalate the user's concerns to a real human or transfer to a human agent. When escalating, the model must tell the customer they are being transferred to a human agent.
+
+In addition, you must add an agent limitations section that contains information regarding never taking actions not defined by the given tools or assuming any information was verified / actions were taken unless explicitly done through a tool execution.
+It should contain in the minimum these core values:
+- Do not answer questions or perform actions outside defined tool capabilities
+- Never assume verification or action completion without explicit tool confirmation
+
+You must also include the following sections:
+1. A section for basic components and objects relevant to the policy:
+    - For example, the idea of a user (e.g. with name, email, etc) and business-specific objects (e.g. reservation for retail/airline/etc, tickets for service, etc.)
+    - This section does not have to be too detailed
+    - Design the objects so that tool parameters can be primitives, not full objects.
+2. Sections for constraints and limitations relevant to interactions with such objects.
+    - For example, if this is an airline policy, there must be constraints for reservation changes, seat changes, baggage policies, etc.
+    - This is the most important part of the policy, and you must think hard and write a concise yet believable constraints.
+
+Do not include the following in the policy:
+- Tools that call other generative models such as pdfs / images / videos should not be added nor considered.
+
+The policy.md is not a description of the business nor a helpful instruction to the agent.
+Instead, it is a strict description of *how* the model should act and *what* constraints there are to its capabilities.
+
+Make sure that the policy has an emphasis on customer service related to the business in the domain {domain}.
+Do not make the generated policy sound like an example template. Make it highly specialized for the specific chatbot and business as if this were a real policy that could be used immediately.
+Ensure that the style, brevity, and realism of the generated policy be akin to the reference policies.

conversational_tool_use_policy_tool_generation/prompts/general_policy_refine.txt

@@ -0,0 +1,27 @@
+Your job is to edit the policy.md file for an automated agent for the {domain} domain.
+Specifically, you will be writing the policy for an automated chatbot agent that a customer to a business in the {domain} domain can interact with.
+You are given a list of reference policies to serve as a guidance for your policy generation.
+
+Your task is as follows:
+1. Carefully read the reference policies and understand the brevity, realism, and style of each.
+2. Find out areas of interest in the current policy that is too verbose, over-detailed, and unnecessary, and remove or edit such parts to mimic the level of detail in the reference policies.
+3. Find out parts of the current policy that lack realism and refine such parts to the level of realism in the reference policies.
+4. Find out styling issues in the current policy and correct them to a coherent styling.
+5. Edit any sections where the agent send emails or texts to the user, as verification should be done by asking the user for their identifying information instead of text codes or etc.
+6. Ensure that there is an explicit agent limitations section setting out clear instructions to avoid answering any questions or take any actions that are not covered by the underlying set of tools, and to not assume any information was verified or action was taken without explicit tool executions.
+7. Write the new policy.md file for the chatbot agent between <policy> </policy> tags.
+
+Make sure the agent limitations section contains in the minimum these core values:
+- Do not answer questions or perform actions outside defined tool capabilities
+- Never assume verification or action completion without explicit tool confirmation
+
+When writing the policy, consider:
+- Keep all original keywords and ideas from the policy.
+
+The new policy should be ready to be directly deployed as the {domain} agent's policy.
+
+{reference_policies}
+
+<original_policy>
+{policy}
+</original_policy>

conversational_tool_use_policy_tool_generation/prompts/general_tools.txt

@@ -0,0 +1,20 @@
+Your job is to generate the tools.jsonl file for the {domain} domain.
+Specifically, you will be writing the tools specification for an automated chatbot agent that assists a customer based on the given policy.
+A reference policy and tools is provided to help show an example output for the task.
+
+Your task is as follows:
+1. Read and think about the provided policy and list out the tools that are mentioned in the policy or should exist to support the agent's actions in the policy.
+2. Deliberate about the input properties and the return types of the tools.
+4. Devise a description and docstring for each tool, as it will be provided to the agent to to be used for interaction with a downstream system.
+5. Create a functional json specification of the tools with correct formatting. Each tool must have the top level keys 'name', 'doc', 'params', and 'returns' with deeper keys including 'properties', 'required' and typing keys as necessary.
+6. Write the tools.jsonl file for the chatbot agent between <tools> </tools> tags.
+
+In addition to the tools in the policy, consider:
+1. The created tools must cover all use cases in the policy. The agent should not be able to perform any concrete action without the use of tools.
+2. Likewise, all actions that the policy can make the user take must be grounded on the agent's use of tools.
+3. Always add an escalation tool, which should be simple and only include a parameter for a summary.
+4. Return types must be explicit and simple. Do not use 'returns' as a return type property name.
+
+Do not write the actual code for tools. Only generate the tool specifications in the form of a jsonl.
+You must include all tools listed in the original policy.
+Ensure that the style, detail, and realism of the generated policy be akin to the reference policies.

conversational_tool_use_policy_tool_generation/prompts/golden_judge.txt

@@ -0,0 +1,20 @@
+Your job is to judge the policy.md and tools.jsonl for an automated agent.
+Specifically, given a list of (policy, tools) pairs that are intended for use by a chatbot agent, choose the worst set of policy and tools that you believe will not work in a real-life setting.
+
+Setting:
+1. policy.md
+    - The policy is what the automated chatbot agent bases their actions upon. It includes the background, the tools provided to the agent, and the constraints for the actions.
+2. tools.jsonl
+    - The list of tools that the agent can use to interact with the underlying system to address the customer's needs. Each tool contains a full json specification for the usage / inputs / outputs of each tool.
+
+Your task is as follows:
+1. Carefully read the policy.md and tools.jsonl pairs for all the provided chatbots.
+2. Check for styling:
+    - If the policy is well-written, the content is cohesive and the style is consistent.
+    - If the tools specifications are complete, make sense in the context of the policy and have no errors.
+3. Check for realism and functional value:
+    - If the policy and tools have real-life use cases and functionalities rather than being toy problems.
+    - If the policy and tools are adopted by an automated chatbot agent, if the agent will bring real value to a business and their customers.
+4. Write your judgment between <judgment> </judgment> tags. For the judgment, Write the index of the single worst policy/tools pair.
+
+Make sure to deliberate deeply and provide resoning before providing a judgment.

conversational_tool_use_policy_tool_generation/prompts/proactive_policy.txt

@@ -0,0 +1,42 @@
+Your job is to generate the policy.md file for an automated agent for the {domain} domain. 
+Specifically, you will be writing the policy for an automated chatbot agent that a customer to a business in the {domain} domain can interact with.
+A reference policy and tools is provided to help show an example output for the task.
+
+Your task is as follows:
+1. Think about the {domain} domain and consider businesses that can span from that domain.
+2. Choose a specific business that can benefit from deploying a chatbot agent that the business' customers can interact with for business-related tasks.
+3. Deliberate about the tools that the chatbot agent can use to interact with an underlying system to resolve a customer's needs. Your tools can be in camel case or snake case. Think of at least 10 tools that can be used by the policy.
+4. Create a policy.md file for the chatbot agent between <policy> </policy> tags.
+
+When writing the policy, consider:
+- Include the current time in the policy the model can refer to, which is {timestamp}.
+- Add a statement to avoid answering questions that the chatbot isn’t qualified to handle—especially those that require advice not based on the policy.
+- Always include a way for the agent to escalate the user's concerns to a real human or transfer to a human agent. When escalating, the model must tell the customer they are being transferred to a human agent.
+
+Make sure the policy contains at least:
+- A few sections for different functionalities of the customer service agent (i.e. enrollment changes, booking modifications, etc).
+- At least one functionality which requires proactive asking from the agent to the user (i.e. can you confirm if you received the invoice? (after sending an invoice and before posting the new payment) or can you check your new status? (after making a status change request and before executing next action)).
+
+In addition, you must add an agent limitations section that contains information regarding never taking actions not defined by the given tools or assuming any information was verified / actions were taken unless explicitly done through a tool execution.
+It should contain in the minimum these core values:
+- Do not answer questions or perform actions outside defined tool capabilities
+- Never assume verification or action completion without explicit tool confirmation
+
+You must also include the following sections:
+1. A section for basic components and objects relevant to the policy:
+    - For example, the idea of a user (e.g. with name, email, etc) and business-specific objects (e.g. reservation for retail/airline/etc, tickets for service, etc.)
+    - This section does not have to be too detailed
+    - Design the objects so that tool parameters can be primitives, not full objects.
+2. Sections for constraints and limitations relevant to interactions with such objects.
+    - For example, if this is an airline policy, there must be constraints for reservation changes, seat changes, baggage policies, etc.
+    - This is the most important part of the policy, and you must think hard and write a concise yet believable constraints.
+
+Do not include the following in the policy:
+- Tools that call other generative models such as pdfs / images / videos should not be added nor considered.
+
+The policy.md is not a description of the business nor a helpful instruction to the agent.
+Instead, it is a strict description of *how* the model should act and *what* constraints there are to its capabilities.
+
+Make sure that the policy has an emphasis on customer service related to the business in the domain {domain}.
+Do not make the generated policy sound like an example template. Make it highly specialized for the specific chatbot and business as if this were a real policy that could be used immediately.
+Ensure that the style, brevity, and realism of the generated policy be akin to the reference policies.

conversational_tool_use_policy_tool_generation/prompts/proactive_policy_refine.txt

@@ -0,0 +1,35 @@
+Your job is to edit the policy.md file for an automated agent for the {domain} domain.
+Specifically, you will be writing the policy for an automated chatbot agent that a customer to a business in the {domain} domain can interact with.
+
+Your task is as follows:
+1. Carefully read the given policy and understand the brevity, realism, and style of each.
+2. Find out areas of interest in the current policy that is too verbose, over-detailed, and unnecessary, and remove or edit such parts to maintain usability of the policy.
+3. Find out parts of the current policy that lack realism and refine such parts to the level of realism of a real customer service agent.
+4. Find out styling issues in the current policy and correct them to a coherent styling.
+5. Ensure that there is an explicit agent limitations section setting out clear instructions to avoid answering any questions or take any actions that are not covered by the underlying set of tools, and to not assume any information was verified or action was taken without explicit tool executions.
+6. Ensure there is a domain basics section which writes out succinctly key objects and their fields relating to the domain the policy is based in.
+7. Edit out / remove an explicit section for a list of tools.
+8. Write the new policy.md file for the chatbot agent between <policy> </policy> tags.
+
+Make sure the policy contains at least:
+- A few sections for different functionalities of the customer service agent (i.e. enrollment changes, booking modifications, etc).
+- At least one functionality which requires proactive asking from the agent to the user (i.e. can you confirm if you received the invoice? (after sending an invoice and before posting the new payment) or can you check your new status? (after making a status change request and before executing next action)).
+
+If there is a section for verifying the identity of the user through a code confirmation sent through SMS / email, make sure the policy explicitly instructs the agent to:
+1. Ask the user for their email / phone number
+2. Call a code-sending tool to send an authentication code to the user at their email / number
+3. Receive the code back from the user
+4. Authenticate the code against the database by calling a verification tool on the code the user provides.
+
+Make sure the agent limitations section contains in the minimum these core values:
+- Do not answer questions or perform actions outside defined tool capabilities
+- Never assume verification or action completion without explicit tool confirmation
+
+When writing the policy, consider:
+- Keep all original keywords and ideas from the policy.
+
+The new policy should be ready to be directly deployed as the {domain} agent's policy.
+
+<original_policy>
+{policy}
+</original_policy>

conversational_tool_use_policy_tool_generation/prompts/proactive_tools.txt

@@ -0,0 +1,21 @@
+Your job is to generate the tools.jsonl file for the {domain} domain.
+Specifically, you will be writing the tools specification for an automated chatbot agent that assists a customer based on the given policy.
+A reference policy and tools is provided to help show an example output for the task.
+
+Your task is as follows:
+1. Read and think about the provided policy and list out the tools that are mentioned in the policy or should exist to support the agent's actions in the policy.
+2. Deliberate about the input properties and the return types of the tools.
+4. Devise a description and docstring for each tool, as it will be provided to the agent to to be used for interaction with a downstream system.
+5. Create a functional json specification of the tools with correct formatting. Each tool must have the top level keys 'name', 'doc', 'params', and 'returns' with deeper keys including 'properties', 'required' and typing keys as necessary.
+6. Write the tools.jsonl file for the chatbot agent between <tools> </tools> tags.
+
+In addition to the tools in the policy, consider:
+1. The created tools must cover all use cases in the policy. The agent should not be able to perform any concrete action without the use of tools.
+2. For instance, if verification is done by sending the user a verification code, make sure there is a tool to send the verification code to the user (after asking the user for their email / phone number) and there is a tool to verify the code the user mentions after.
+3. Likewise, all actions that the policy can make the user take must be grounded on the agent's use of tools.
+4. Always add an escalation tool, which should be simple and only include a parameter for a summary.
+5. Return types must be explicit and simple. Do not use 'returns' as a return type property name.
+
+Do not write the actual code for tools. Only generate the tool specifications in the form of a jsonl.
+You must include all tools listed in the original policy.
+Ensure that the style, detail, and realism of the generated policy be akin to the reference policies.

conversational_tool_use_policy_tool_generation/prompts/tools_refine.txt

@@ -0,0 +1,27 @@
+Your job is to edit the tools.jsonl file for the {domain} domain given the policy.md.
+Specifically, you will be writing the tools specification for an automated chatbot agent that assists a customer based on the given policy.
+You are given a list of reference tools to serve as a guidance for your tool generation.
+
+Your task is as follows:
+1. Carefully read the provided policy.md and existing tools.jsonl and check if the original tools fit naturally for the use cases of the policy.
+2. If a tool is referenced in the policy but omitted in the tools.jsonl, draft a new tool specification to be provided to the agent based on the description in the policy.
+3. If an existing tool's execution result must be followed up with another tool, make sure that follow-up tool exists. If it does not exist, create the tool.
+4. If the user can take any action based on the agent's directions as per the policy, make sure that agent's directions are grounded on a tool that exists. If it does not exist, create the tool.
+5. Write the edited tools.jsonl file for the chatbot agent between <tools> </tools> tags.
+
+When writing the the tools list, consider:
+1. Do not change the original tools list too much unless needed.
+2. For existing tools, if they should not be edited, leave them as they are. For tools that must be added or edited, make sure they match the styling of the existing tools and the specifications in the policy.
+3. Make sure to create a functional json specification of the tools with correct formatting. Each tool must have the top level keys 'name', 'doc', 'params', and 'returns' with deeper keys including 'properties', 'required' and typing keys as necessary.
+4. Return types must be explicit and simple. Do not use 'returns' as a return type property name.
+
+Do not write the actual code for tools. Only generate the tool specifications in the form of a jsonl.
+You must include all tools listed in the policy.
+
+<policy>
+{policy}
+</policy>
+
+<original_tools.jsonl>
+{tools}
+</original_tools.jsonl>

conversational_tool_use_scenario_generation/prompts/scenario_system.txt

@@ -0,0 +1,7 @@
+Your task is to create example customer scenarios within a specified setting.  In the setting, a customer service representative responds to requests for assistance from customers.  The way that the representative handles requests is described below between the <policy> and </policy> tags.
+
+<policy>
+{domain_policy}
+</policy>
+
+Each customer scenario should describe the customer and the tasks that the customer is trying to complete by contacting the representative.  Please make sure that in each scenario, the policy {policy_scope_instruction} the way the representative should handle a request that the customer would make to the representative to complete their tasks.

conversational_tool_use_scenario_generation/prompts/scenario_user.txt

@@ -0,0 +1,2 @@
+Please create {scenario_count} different customer scenarios that describe customers who would contact the representative to complete tasks.  Please output the collection of customer scenarios using the following JSON schema:
+{scenarios_schema}

conversational_tool_use_simulation/prompts/agent_conversation_evaluation_system.txt

@@ -0,0 +1,27 @@
+# Instructions
+- Your task is to evaluate the actions taken by a customer service representative in an interaction between a customer and the representative.
+- The steps in the interaction are shown in order between the <steps> and </steps> tags.
+- Each step in the interaction is either a message from the customer to the representative, a message from the representative to the customer, the execution of a tool, or the result of executing a tool.
+- A message from the customer to the representative or from the representative to the customer is shown between <message> and </message> tags.
+- An execution of a tool can be requested by the representative, and is shown between <execute_tool> and </execute_tool> tags.
+- When the representative requests the execution of a tool, the next step in the interaction should be the result of executing the tool, which is shown between <tool_result> and </tool_result> tags.
+- The way that the representative handles customer requests is described below between the <policy> and </policy> tags.
+- The definitions of the tools that are available to the representative for execution are provided below between the <tools> and </tools> tags, with each tool definition appearing between <tool> and </tool> tags.
+- Whenever the representative takes an action, the representative can either send a message to the customer, or execute a tool.
+- The actions of the representative should be considered a success if they are helpful in addressing the request from the customer.
+- The actions of the representative should be considered a failure if they do not help to handle the customer's request, or are not consistent with the steps in the interaction that precede them or the policy for handling customer requests.
+
+<policy>
+{policy}
+</policy>
+
+<tools>
+{tool_definitions}
+</tools>
+
+- The representative can transfer the customer to another agent.  This should be done if the customer's request cannot be handled by the representative according to the policy, but should not be done if the representative can handle the request under the policy.
+- In this interaction, the representative should {transfer_instruction}transfer the customer to another agent.
+- The actions of the representative should be considered a failure if the representative transfers the customer to another agent when they should not transfer the customer, or if the representative does not transfer the customer to another agent when they should transfer the customer.
+
+Please output the evaluation of the actions taken by the customer service representative and an explanation for the evaluation using the following JSON schema:
+{evaluation_schema}

conversational_tool_use_simulation/prompts/agent_message_evaluation_system.txt

@@ -0,0 +1,28 @@
+# Instructions
+- Your task is to evaluate one step in an interaction between a customer and a customer service representative.
+- The previous steps in the interaction are shown in order between the <previous_steps> and </previous_steps> tags.
+- The step that you are to evaluate is the current step, which is shown between the <current_step> and </current_step> tags.
+- Each step in the interaction is either a message from the customer to the representative, a message from the representative to the customer, the execution of a tool, or the result of executing a tool.
+- A message from the customer to the representative or from the representative to the customer is shown between <message> and </message> tags.
+- An execution of a tool can be requested by the representative, and is shown between <execute_tool> and </execute_tool> tags.
+- When the representative requests the execution of a tool, the next step in the interaction should be the result of executing the tool, which is shown between <tool_result> and </tool_result> tags.
+- The way that the representative handles customer requests is described below between the <policy> and </policy> tags.
+
+<policy>
+{policy}
+</policy>
+
+- The definitions of the tools that are available to the representative for execution are provided below between the <tools> and </tools> tags, with each tool definition appearing between <tool> and </tool> tags.
+
+<tools>
+{tool_definitions}
+</tools>
+
+- The current step that you are to evaluate is an action by the representative.
+- The representative can either send a message to the customer, or execute a tool.
+- The current step should be considered a success if the action taken by the representative is helpful in addressing the request from the customer.
+- The current step should be considered a failure if the action taken by the representative does not help to handle the customer's request, or is not consistent with the previous steps in the interaction or the policy for handling customer requests.
+- If the current step is the execution of a tool, then the current step should be considered a success if the tool to be executed helps to address the customer's request, the arguments for the tool execution conform to the tool definition, and the arguments are consistent with the previous steps in the conversation.  Otherwise, the current step should be considered a failure.
+
+Please output the evaluation of the current step and an explanation for the evaluation using the following JSON schema:
+{evaluation_schema}

conversational_tool_use_simulation/prompts/complete_conversation.txt

@@ -0,0 +1,3 @@
+<steps>
+{steps}
+</steps>

conversational_tool_use_simulation/prompts/environment_conversation.txt

@@ -0,0 +1,4 @@
+<conversation>
+{conversation}
+</conversation>
+

conversational_tool_use_simulation/prompts/environment_conversation_message.txt

@@ -0,0 +1,3 @@
+<{sender}>
+{message}
+</{sender}>

conversational_tool_use_simulation/prompts/environment_message_evaluation_system.txt

@@ -0,0 +1,32 @@
+# Instructions
+- Your task is to evaluate one step in an interaction between a customer and a customer service representative.
+- The previous steps in the interaction are shown in order between the <previous_steps> and </previous_steps> tags.
+- The step that you are to evaluate is the current step, which is shown between the <current_step> and </current_step> tags.
+- Each step in the interaction is either a message from the customer to the representative, a message from the representative to the customer, the execution of a tool, or the result of executing a tool.
+- A message from the customer to the representative or from the representative to the customer is shown between <message> and </message> tags.
+- An execution of a tool can be requested by the representative, and is shown between <execute_tool> and </execute_tool> tags.
+- When the representative requests the execution of a tool, the next step in the interaction should be the result of executing the tool, which is shown between <tool_result> and </tool_result> tags.
+- The way that the representative handles customer requests is described below between the <policy> and </policy> tags.
+
+<policy>
+{policy}
+</policy>
+
+- The scenario that describes the customer and the tasks they are trying to complete is shown below between the <scenario> and </scenario> tags.
+- The definitions of the tools that are available for execution are provided below between the <tools> and </tools> tags, with each tool definition appearing between <tool> and </tool> tags.
+
+<scenario>
+{customer_scenario}
+</scenario>
+
+<tools>
+{tool_definitions}
+</tools>
+
+- The current step that you are to evaluate is the result of executing a tool.
+- The previous step in the interaction should specify the tool to be executed and the arguments for execution.
+- The current step should be considered a success if the tool execution result conforms to the definition of the tool being executed, and is consistent with the information about the customer in the scenario and the previous steps in the interaction.
+- The current step should be considered a failure if the tool execution result is not consistent with the definition of the tool being executed, the information about the customer in the scenario, or the previous steps in the interaction.
+
+Please output the evaluation of the current step and an explanation for the evaluation using the following JSON schema:
+{evaluation_schema}

conversational_tool_use_simulation/prompts/environment_simulator_system.txt

@@ -0,0 +1,21 @@
+# Instructions
+- Your task is to generate the result of executing a tool.
+- The tool is executed by a customer service representative in the context of a conversation with a customer to retrieve information or accomplish a task.
+- The conversation between the customer and the representative is shown between <conversation> and </conversation> tags, with each message sent by the customer appearing between <customer> and </customer> tags, and each message sent by the customer service representative appearing between <representative> and </representative> tags.
+- The way that the representative handles customer requests is described below between the <policy> and </policy> tags.
+- The scenario that describes the customer and the tasks that they are trying to complete is shown below between the <scenario> and </scenario> tags.
+- The definitions of the available tools are provided below between the <tools> and </tools> tags, with each tool definition appearing between <tool> and </tool> tags.
+
+<policy>
+{domain_policy}
+</policy>
+
+<scenario>
+{customer_scenario}
+</scenario>
+
+<tools>
+{tool_definitions}
+</tools>
+
+Please make sure that the tool execution result that you generate is consistent with the definition of the tool being executed, the information about the customer in the scenario, and the previous conversation between the customer and the representative.  Please output only the execution result of the tool that is to be executed.

conversational_tool_use_simulation/prompts/environment_user_model_message.txt

@@ -0,0 +1,2 @@
+{conversation}Tool to execute: {tool_name}
+Arguments for tool execution: {arguments}

conversational_tool_use_simulation/prompts/message_conversation.txt

@@ -0,0 +1,7 @@
+<previous_steps>
+{previous_steps}
+</previous_steps>
+
+<current_step>
+{current_step}
+</current_step>

conversational_tool_use_simulation/prompts/message_system_prefix.txt

@@ -0,0 +1,14 @@
+# Instructions
+- Your task is to evaluate one step in an interaction between a customer and a customer service representative.
+- The previous steps in the interaction are shown in order between the <previous_steps> and </previous_steps> tags.
+- The step that you are to evaluate is the current step, which is shown between the <current_step> and </current_step> tags.
+- Each step in the interaction is either a message from the customer to the representative, a message from the representative to the customer, the execution of a tool, or the result of executing a tool.
+- A message from the customer to the representative or from the representative to the customer is shown between <message> and </message> tags.
+- An execution of a tool can be requested by the representative, and is shown between <execute_tool> and </execute_tool> tags.
+- When the representative requests the execution of a tool, the next step in the interaction should be the result of executing the tool, which is shown between <tool_result> and </tool_result> tags.
+- The way that the representative handles customer requests is described below between the <policy> and </policy> tags.
+
+<policy>
+{policy}
+</policy>
+

conversational_tool_use_simulation/prompts/text_message.txt

@@ -0,0 +1,4 @@
+<message>
+Sender: {sender}
+Content: {content}
+</message>

conversational_tool_use_simulation/prompts/tool_call_message.txt

@@ -0,0 +1,5 @@
+<execute_tool>
+Execution ID: {execution_id}
+Tool name: {tool_name}
+Arguments for execution: {arguments}
+</execute_tool>

conversational_tool_use_simulation/prompts/tool_definition.txt

@@ -0,0 +1,6 @@
+<tool>
+Name: {name}
+Documentation: {documentation}
+Parameters in JSON Schema format: {parameters}
+Return type in JSON Schema format: {return_type}
+</tool>

conversational_tool_use_simulation/prompts/tool_execution_message.txt

@@ -0,0 +1,4 @@
+<tool_result>
+Execution ID: {execution_id}
+Execution result: {execution_result}
+</tool_result>

conversational_tool_use_simulation/prompts/user_agent_environment_conversation_evaluation_system.txt

@@ -0,0 +1,42 @@
+# Instructions
+- Your task is to evaluate an interaction between a customer and a customer service representative.
+- Please evaluate separately the actions of the customer, the actions of the representative, and the tool results in the interaction.
+- The steps in the interaction are shown in order between the <steps> and </steps> tags.
+- Each step in the interaction is either a message from the customer to the representative, a message from the representative to the customer, the execution of a tool, or the result of executing a tool.
+- A message from the customer to the representative or from the representative to the customer is shown between <message> and </message> tags.
+- An execution of a tool can be requested by the representative, and is shown between <execute_tool> and </execute_tool> tags.
+- When the representative requests the execution of a tool, the next step in the interaction should be the result of executing the tool, which is shown between <tool_result> and </tool_result> tags.
+- The way that the representative handles customer requests is described below between the <policy> and </policy> tags.
+- The definitions of the tools that are available to the representative for execution are provided below between the <tools> and </tools> tags, with each tool definition appearing between <tool> and </tool> tags.
+- The scenario that describes the customer and the tasks they are trying to complete is shown below between the <scenario> and </scenario> tags.
+
+<policy>
+{policy}
+</policy>
+
+<tools>
+{tool_definitions}
+</tools>
+
+<scenario>
+{customer_scenario}
+</scenario>
+
+- The goal of the customer is to complete the tasks described in the scenario by communicating with the representative, while maintaining consistency with the information about the customer in the scenario.
+- The actions of the customer should be considered a success if they follow naturally from the interaction with the representative and are consistent with the scenario.
+- The actions of the customer should be considered a failure if they do not advance the interaction or are not consistent with the scenario.
+- The customer should send the message '{complete_indicator}' to end the interaction with the representative when their tasks have been completed.
+- The customer should send the message '{transfer_indicator}' when they have been transferred to another agent by the representative.
+- The actions of the customer should be considered a failure if the customer ends the interaction when their tasks have not yet been completed, or sends the message '{transfer_indicator}' when they have not yet been transferred to another agent by the representative.
+- Whenever the representative takes an action, the representative can either send a message to the customer, or execute a tool.
+- The actions of the representative should be considered a success if they are helpful in addressing the request from the customer.
+- The actions of the representative should be considered a failure if they do not help to handle the customer's request, or are not consistent with the steps in the interaction that precede them or the policy for handling customer requests.
+- The representative can transfer the customer to another agent.  This should be done if the customer's request cannot be handled by the representative according to the policy, but should not be done if the representative can handle the request under the policy.
+- In this interaction, the representative should {transfer_instruction}transfer the customer to another agent.
+- The actions of the representative should be considered a failure if the representative transfers the customer to another agent when they should not transfer the customer, or if the representative does not transfer the customer to another agent when they should transfer the customer.
+- When the representative executes a tool, the tool execution step should specify the tool to be executed and the arguments for execution, and the next step should be the result of executing the tool.
+- The tool results in the interaction should be considered a success if they conform to the definitions of the tools being executed, and are consistent with the arguments for execution, the information about the customer in the scenario, the interaction between the customer and the representative, and each other.
+- The tool results in the interaction should be considered a failure if they are not consistent with the definitions of the tools being executed, the arguments for execution, the information about the customer in the scenario, the interaction between the customer and the representative, or each other.
+
+Please output the evaluation of the actions taken by the customer, the evaluation of the actions taken by the customer service representative, the evaluation of the tool results in the interaction, and explanations for the evaluations using the following JSON schema:
+{evaluation_schema}

conversational_tool_use_simulation/prompts/user_message_evaluation_system.txt

@@ -0,0 +1,29 @@
+# Instructions
+- Your task is to evaluate one step in an interaction between a customer and a customer service representative.
+- The previous steps in the interaction are shown in order between the <previous_steps> and </previous_steps> tags.
+- The step that you are to evaluate is the current step, which is shown between the <current_step> and </current_step> tags.
+- Each step in the interaction is either a message from the customer to the representative, a message from the representative to the customer, the execution of a tool, or the result of executing a tool.
+- A message from the customer to the representative or from the representative to the customer is shown between <message> and </message> tags.
+- An execution of a tool can be requested by the representative, and is shown between <execute_tool> and </execute_tool> tags.
+- When the representative requests the execution of a tool, the next step in the interaction should be the result of executing the tool, which is shown between <tool_result> and </tool_result> tags.
+- The way that the representative handles customer requests is described below between the <policy> and </policy> tags.
+
+<policy>
+{policy}
+</policy>
+
+- The scenario that describes the customer and the tasks they are trying to complete is shown below between the <scenario> and </scenario> tags.
+
+<scenario>
+{customer_scenario}
+</scenario>
+
+- The current step that you are to evaluate is a message from the customer to the representative.
+- The current step should be considered a success if the message from the customer to the representative follows naturally from the previous steps in the interaction and is consistent with the information about the customer in the scenario.
+- If the message from the customer to the representative in the current step does not advance the interaction, is not consistent with the scenario, or is not consistent with the previous steps in the interaction, then the current step should be considered a failure.
+- If the current step is the first step in the interaction, then it should be considered a success if it is consistent with the scenario, and it should be considered a failure if it is not consistent with the scenario.  A first step can be successful even if the customer does not include some information that would be needed by the representative, because the representative can request the information from the customer in later steps.
+- The customer will send the message '{complete_indicator}' to indicate that they would like to end the interaction with the representative.  If the current step contains this message, then it should be considered a success if the customer's tasks have been completed by the interaction, and it should be considered a failure if the customer's tasks have not yet been completed.
+- The customer will send the message '{transfer_indicator}' to indicate that they have been transferred to another agent by the representative.  If the current step contains this message, then it should be considered a success if the representative previously transferred the customer to another agent, and it should be considered a failure if the representative has not yet transferred the customer to another agent.
+
+Please output the evaluation of the current step and an explanation for the evaluation using the following JSON schema:
+{evaluation_schema}

conversational_tool_use_simulation/prompts/user_simulator_system.txt

@@ -0,0 +1,16 @@
+# Instructions
+- You are playing the role of a customer contacting a customer service representative.
+- The scenario that describes the customer that you are acting as and the tasks that are to be completed is included below between the <scenario> and </scenario> tags.
+- Strictly follow the instructions in the scenario description.
+- To start a conversation, please make a request to the customer service representative in order to complete the tasks described in the scenario.
+- Generate one message at a time, maintaining natural conversation flow.
+- Each message should be a message from a customer to the representative.
+- The goal is to continue the conversation until the tasks are complete.
+- If the tasks have been completed during the previous messages in the interaction with the customer service representative, then instead of generating a message, output just '{complete_indicator}' to indicate that the conversation should end.
+- If you are transferred to another agent by the customer service representative in a previous message in the conversation, then instead of generating a message, output just '{transfer_indicator}' to indicate the transfer.
+
+<scenario>
+{customer_scenario}
+</scenario>
+
+Remember: The goal is to create realistic, natural conversations while strictly adhering to the provided instructions and maintaining character consistency.