Merge pull request #12 from anthropics/messages

Messages

Author: nmarwell-anthropic

README.md

@@ -80,25 +80,26 @@ time_tool_user = ToolUser([time_of_day_tool])
 
 You can then make use of your ToolUser by calling its `use_tools()` method and passing in your desired prompt. Setting execution mode to "automatic" makes it execute the function; in the default "manual" mode it returns the function arguments back to the client to be executed there.
 ```python
-messages = [{'role': 'human', 'content': 'What time is it in Los Angeles?'}]
+messages = [{'role': 'user', 'content': 'What time is it in Los Angeles?'}]
 time_tool_user.use_tools(messages, execution_mode='automatic')
 ```
 
 If you are accesing Claude through AWS Bedrock, set the parameter `first_party` to `False` (it is by default set to `True`):
 ```python
 time_tool_user = ToolUser([time_of_day_tool], first_party=False)
 ```
+NOTE: If using bedrock, this SDK only supports claude 2.1 (anthropic.claude-v2:1).
 
 Notice that new `messages` format instead of passing in a simple prompt string? Never seen it before? Don't worry, we are about to walk through it.
 
-### New Prompt Format
-Historically, interacting with Claude required that you directly pass it a string (including any required Human/Assistant formatting), and get back a string. This was already somewhat error prone from both an input and parsing standpoint and became more cumbersome to deal with in the context of tool use. The result is that anthropic-tools uses a new, *structured* prompt input and output format, coming as a list of messages. Let's take a quick tour of how to work with this list.
+### Prompt Format
+Anthropic-tools uses a *structured* prompt input and output format, coming as a list of messages, intending to mimic our Messages API format. Let's take a quick tour of how to work with this list.
 
 `messages` is a python list of message dictionaries. A single message dictionary object can contain these fields but will never contain all of them (see the field comments below for more detail on what this means):
 ```python
 {
-    "role": str, # The role of the message. 'human' for a message from the human, 'assistant' for a message from the assistant, 'tool_inputs' for a request from the assistant to use tools, 'tool_outputs' for a response to a tool_inputs message containing the results of using the specified tools in the specified ways.
-    "content": str, # The (non tool use) content of the message, which must be present for messages where role=(human, assistant, tool_inputs) and can not be present for messages where role=tool_outputs.
+    "role": str, # The role of the message. 'user' for a message from the user, 'assistant' for a message from the assistant, 'tool_inputs' for a request from the assistant to use tools, 'tool_outputs' for a response to a tool_inputs message containing the results of using the specified tools in the specified ways.
+    "content": str, # The (non tool use) content of the message, which must be present for messages where role=(user, assistant, tool_inputs) and can not be present for messages where role=tool_outputs.
     "tool_inputs": list[dict], # A list of dictionaries (see below). Must be specified in messages where role=tool_inputs.
     "tool_outputs": list[dict], # A list of tool_output dictionaries (see below). One of tool_outputs or tool_error must be specified in messages where role=tool_outputs, but the other must be specified as None.
     "tool_error": str # A tool error message corresponding to the first tool that errored to help Claude understand what it did wrong. One of tool_error or tool_outputs must be specified when role=tool_outputs, but the other must be specified as None.
@@ -164,21 +165,21 @@ Sometimes when Claude responds with a `tool_inputs` message it makes a mistake a
 ```
 
 So, what might `messages` look like in practice?  
-Here is a human message:
+Here is a user message:
 ```python
-human_message = {'role': 'human', 'content': 'Hi Claude, what US states start with C?'}
-messages = [human_message]
+user_message = {'role': 'user', 'content': 'Hi Claude, what US states start with C?'}
+messages = [user_message]
 ```
-Here is a human message and an assistant response, with no tool use involved.
+Here is a user message and an assistant response, with no tool use involved.
 ```python
-human_message = {'role': 'human', 'content': 'Hi Claude, what US states start with C?'}
+user_message = {'role': 'humuseran', 'content': 'Hi Claude, what US states start with C?'}
 assistant_message = {'role': 'assistant', 'content': 'California, Colorado, and Connecticut are the US states that start with the letter C.'}
-messages = [human_message, assistant_message]
+messages = [user_message, assistant_message]
 ```
 
-Here is a human message, followed by a tool_inputs message, followed by a successful tool_outputs message:
+Here is a user message, followed by a tool_inputs message, followed by a successful tool_outputs message:
 ```python
-human_message = {'role': 'human', 'content': 'If Maggie has 3 apples and eats 1, how many apples does maggie have left?'}
+user_message = {'role': 'user', 'content': 'If Maggie has 3 apples and eats 1, how many apples does maggie have left?'}
 tool_inputs_message = {
     'role': 'tool_inputs',
     'content': "Let's think this through. Maggie had 3 apples, she ate one so:",
@@ -189,12 +190,12 @@ tool_outputs_message = {
     'tool_outputs': [{"tool_name": 'perform_subtraction', 'tool_result': 2}],
     'tool_error': None
 }
-messages = [human_message, tool_inputs_message, tool_outputs_message]
+messages = [user_message, tool_inputs_message, tool_outputs_message]
 ```
 
 And here is what it would look like instead if Claude made a mistake and `perform_subtraction` failed.
 ```python
-human_message = {'role': 'human', 'content': 'If Maggie has 3 apples and eats 1, how many apples does maggie have left?'}
+user_message = {'role': 'user', 'content': 'If Maggie has 3 apples and eats 1, how many apples does maggie have left?'}
 tool_inputs_message = {
     'role': 'tool_inputs',
     'content': "Let's think this through. Maggie had 3 apples, she ate one so:",
@@ -205,7 +206,7 @@ tool_outputs_message = {
     'tool_outputs': None,
     'tool_error': 'Missing required parameter "b" in tool perform_subtraction.'
 }
-messages = [human_message, tool_inputs_message, tool_outputs_message]
+messages = [user_message, tool_inputs_message, tool_outputs_message]
 ```
 
 That's it for the new messages format. To help wrap your head around this concept, at the end of the "Putting it Together" section below, we will build a python function to handle these sorts of requests.
@@ -249,12 +250,12 @@ subtraction_tool = SubtractionTool(subtraction_tool_name, subtraction_tool_descr
 math_tool_user = ToolUser([addition_tool, subtraction_tool])
 
 # Build messages
-human_message = {
-    "role": "human",
+user_message = {
+    "role": "user",
     "content": "Sally has 17 apples. She gives 9 to Jim. Later that day, Peter gives 6 Bananas to Sally. How many pieces of fruit does Sally have at the end of the day?"
 }
 
-messages = [human_message]
+messages = [user_message]
 
 # Use Claude With the Provided Tools
 math_tool_user.use_tools(messages, execution_mode='automatic')

requirements.txt

@@ -1,8 +1,8 @@
 aiohttp==3.8.6
 aiosignal==1.3.1
 annotated-types==0.6.0
-anthropic==0.4.1
-anthropic-bedrock==0.4.0
+anthropic==0.16.0
+anthropic-bedrock==0.8.0
 anyio==3.7.1
 async-timeout==4.0.3
 attrs==23.1.0

tool_use_package/EXAMPLES.md

@@ -56,7 +56,7 @@ We then call tool_user.use_tools() with our query to let claude answer our quest
 tool_user = ToolUser([weather_tool])
 
 # Call the tool_user with a prompt to get a version of Claude that can use your tools!
-messages = [{"role": "human", "content": "I live in San Francisco, what shold I wear today?"}]
+messages = [{"role": "user", "content": "I live in San Francisco, what shold I wear today?"}]
 print(tool_user.use_tools(messages, execution_mode='automatic'))
 ```
 You may also notice that we set `execution_mode='automatic'`, recall that this means Claude will have its tool usage requests automatically executed and fed back in until it decides it has done enough to answer your query, at which point it will respond to you with that answer. If you set `execution_mode='manual'`, Claude will stop after its first request to use a tool/tools and you will be returned the requested tool(s) to use and the arguments to use them with.
@@ -141,7 +141,7 @@ Finally, we pass `sql_tool` to `ToolUser` and run our query!
 ```python
 tool_user = ToolUser([sql_tool])
 
-messages = [{"role": "human", "content": "Who is our oldest employee?"}]
+messages = [{"role": "user", "content": "Who is our oldest employee?"}]
 print(tool_user.use_tools(messages, single_function_call=False))
 ```
 When you are done you can either manually delete the test.db file or run `os.remove('test.db')` to get rid of the temporary database we created.
@@ -233,7 +233,7 @@ Finally, we pass our `amazon_search_tool` to `ToolUser`, define our message, and
 ```python
 tool_user = ToolUser([amazon_search_tool])
 
-messages = [{"role":"human", "content":"I want to get my daughter more interested in science. What kind of gifts should I get her?"}]
+messages = [{"role":"user", "content":"I want to get my daughter more interested in science. What kind of gifts should I get her?"}]
 
 print(tool_user.use_tools(messages, execution_mode="automatic"))
 ```
@@ -340,7 +340,7 @@ Finally, we pass our `amazon_search_tool` to `ToolUser`, define our message, and
 ```python
 tool_user = ToolUser([amazon_search_tool])
 
-messages = [{"role":"human", "content":"I want to get my daughter more interested in science. What kind of gifts should I get her?"}]
+messages = [{"role":"user", "content":"I want to get my daughter more interested in science. What kind of gifts should I get her?"}]
 
 print(tool_user.use_tools(messages, execution_mode="automatic"))
 ```

tool_use_package/calculator_example.py

@@ -46,5 +46,5 @@ def use_tool(self, a, b):
 
 # Call the tool_user with a prompt to get a version of Claude that can use your tools!
 if __name__ == '__main__':
-    messages = [{"role":"human", "content":"John has three apples. Maggie has nine apples. Tim has 4 bananas. If John gives Maggie 1 apple and Tim gives John 2 bananas, how much fruit does each person have?"}]
+    messages = [{"role":"user", "content":"John has three apples. Maggie has nine apples. Tim has 4 bananas. If John gives Maggie 1 apple and Tim gives John 2 bananas, how much fruit does each person have?"}]
     print(tool_user.use_tools(messages, execution_mode="automatic"))

tool_use_package/messages_api_converters.py

@@ -0,0 +1,58 @@
+def convert_completion_to_messages(completion):
+    result = {"messages": []}
+    
+    parts = completion.split('\n\nHuman:')
+    if len(parts) < 2:
+        raise ValueError("No human message found in the completion")
+    
+    # Assign the first part as the system message
+    result["system"] = parts[0].strip()
+    
+    # Process the remaining parts
+    for i in range(1, len(parts)):
+        content_parts = parts[i].split('\n\nAssistant:', 1)
+
+        result["messages"].append({"role": "user", "content": content_parts[0].strip()})
+        
+        if len(content_parts) == 2:
+            result["messages"].append({"role": "assistant", "content": content_parts[1].strip()})
+        elif len(content_parts) > 2:
+            # If there are more than two parts, it means there are consecutive assistant messages
+            raise ValueError("Consecutive assistant messages found")
+        elif i < len(parts) - 1:
+            # If there is no assistant message and it's not the last part, raise an error for consecutive human messages
+            raise ValueError("Consecutive human messages found")
+    
+    return result
+
+class MiniCompletion:
+    def __init__(self, stop_reason, stop, completion):
+        self.stop_reason = stop_reason
+        self.stop = stop
+        self.completion = completion
+
+
+def convert_messages_completion_object_to_completions_completion_object(message):
+    if message.stop_reason == 'end_turn':
+        stop_reason = 'stop_sequence'
+    elif message.stop_reason == 'stop_sequence':
+        stop_reason = 'stop_sequence'
+    else:
+        stop_reason =  message.stop_reason
+
+    if message.stop_sequence is None:
+        stop_sequence = '\n\nHuman:'
+    else:
+        stop_sequence = message.stop_sequence
+
+    if message.content:
+        if message.content[0].text:
+            content = message.content[0].text
+    else:
+        content=''
+
+    return MiniCompletion(
+        stop_reason=stop_reason,
+        stop=stop_sequence,
+        completion=content
+    )

tool_use_package/prompt_constructors.py

@@ -25,7 +25,7 @@ def construct_tool_use_system_prompt(tools):
     return tool_use_system_prompt
 
 def construct_use_tools_prompt(prompt, tools, last_message_role):
-    if last_message_role == 'human':
+    if last_message_role == 'user':
         constructed_prompt = (
             f"{construct_tool_use_system_prompt(tools)}"
             f"{prompt}"
@@ -108,27 +108,27 @@ def construct_prompt_from_messages(messages):
 
     constructed_prompt = ""
     for i, message in enumerate(messages):
-        if message['role'] == 'human':
-            if (i > 0 and messages[i-1]['role'] != 'human') or i == 0:
+        if message['role'] == 'user':
+            if (i > 0 and messages[i-1]['role'] != 'user') or i == 0:
                 constructed_prompt = f"{constructed_prompt}\n\nHuman: {message['content']}"
             else:
                 constructed_prompt = f"{constructed_prompt}\n\n{message['content']}"
         if message['role'] == 'assistant':
-            if (i > 0 and messages[i-1]['role'] == 'human') or i == 0:
+            if (i > 0 and messages[i-1]['role'] == 'user') or i == 0:
                 constructed_prompt = f"{constructed_prompt}\n\nAssistant: {message['content']}"
             else:
                 constructed_prompt = f"{constructed_prompt}\n\n{message['content']}"
         if message['role'] == 'tool_inputs':
             appendage = construct_tool_inputs_message(message['content'], message['tool_inputs'])
-            if (i > 0 and messages[i-1]['role'] == 'human') or i == 0:
+            if (i > 0 and messages[i-1]['role'] == 'user') or i == 0:
                 constructed_prompt = f"{constructed_prompt}\n\nAssistant:{appendage}"
             elif message['content'] == "":
                 constructed_prompt = f"{constructed_prompt}{appendage}"
             else:
                 constructed_prompt = f"{constructed_prompt}\n\n{appendage}"
         if message['role'] == 'tool_outputs':
             appendage = construct_tool_outputs_message(message['tool_outputs'], message['tool_error'])
-            if (i > 0 and messages[i-1]['role'] == 'human') or i == 0:
+            if (i > 0 and messages[i-1]['role'] == 'user') or i == 0:
                 constructed_prompt = f"{constructed_prompt}\n\nAssistant:{appendage}"
             else:
                 constructed_prompt = f"{constructed_prompt}{appendage}"
@@ -141,19 +141,19 @@ def validate_messages(messages):
     if len(messages) < 1:
         raise ValueError("Messages must be a list of length > 0.")
 
-    valid_roles = ['human', 'assistant', 'tool_inputs', 'tool_outputs']
+    valid_roles = ['user', 'assistant', 'tool_inputs', 'tool_outputs']
     for message in messages:
         if not isinstance(message, dict):
             raise ValueError("All messages in messages list should be dictionaries.")
         if 'role' not in message:
             raise ValueError("All messages must have a 'role' key.")
         if message['role'] not in valid_roles:
             raise ValueError(f"{message['role']} is not a valid role. Valid roles are {valid_roles}")
-        if message['role'] == 'human' or message['role'] == 'assistant':
+        if message['role'] == 'user' or message['role'] == 'assistant':
             if 'content' not in message:
-                raise ValueError("All messages with human or assistant roles must have a 'content' key.")
+                raise ValueError("All messages with user or assistant roles must have a 'content' key.")
             if not isinstance(message['content'], str):
-                raise ValueError("For messages with role='human' or role='assistant', content must be a string.")
+                raise ValueError("For messages with role='user' or role='assistant', content must be a string.")
         if message['role'] == 'tool_inputs':
             if 'tool_inputs' not in message:
                 raise ValueError("All messages with tool_inputs roles must have a 'tool_inputs' key.")

tool_use_package/tests/test_prompt_constructors.py

@@ -22,7 +22,7 @@
 class TestPromptConstructors(unittest.TestCase):
     def test_construct_use_tools_prompt(self):
         tools = [weather_tool]
-        self.assertEqual(construct_use_tools_prompt("\n\nHuman: I live in San Francisco, what shold I wear today?", tools, 'human'), test_use_tools_prompt)
+        self.assertEqual(construct_use_tools_prompt("\n\nHuman: I live in San Francisco, what shold I wear today?", tools, 'user'), test_use_tools_prompt)
 
     def test_construct_successful_function_run_injection_prompt(self):
         self.assertEqual(construct_successful_function_run_injection_prompt([{"tool_name": "perform_addition", "tool_result": 8}]), test_successful_function_run_injection_prompt)