Use responses API

Author: tygern

discovery/agent_support/agent.py

@@ -4,6 +4,9 @@
 from typing import List
 
 from openai import OpenAI
+from openai.types.responses import EasyInputMessageParam, Response, ResponseFunctionToolCallParam, \
+    ResponseFunctionToolCall
+from openai.types.responses.response_input_param import Message, ResponseInputParam, FunctionCallOutput
 
 from discovery.agent_support.tool import Tool
 
@@ -23,51 +26,55 @@ class AgentResult:
 
 
 class Agent:
-    def __init__(self, client: OpenAI, model: str, instructions: str, tools: List[Tool]):
+    def __init__(self, client: OpenAI, model: str, system_instructions: str, tools: List[Tool]):
         self.client = client
+        self.model = model
+        self.instructions = system_instructions
         self.tools = tools
-        self.assistant_id = client.beta.assistants.create(
-            instructions=instructions,
-            model=model,
-            tools=[tool.schema() for tool in tools]
-        ).id
+        self.tool_params = [tool.tool_param() for tool in tools]
 
     def answer(self, question: str) -> AgentResult:
-        thread = self.client.beta.threads.create()
-        tool_calls = []
-        self.client.beta.threads.messages.create(
-            thread_id=thread.id,
-            role="user",
-            content=question,
-        )
-
-        run = self.client.beta.threads.runs.create_and_poll(thread_id=thread.id, assistant_id=self.assistant_id)
-        while run.status != "completed":
-            logger.debug(f"status %s", run.status)
-            tool_outputs = []
-            for tool_call in run.required_action.submit_tool_outputs.tool_calls:
-                tool_name = tool_call.function.name
-                arguments = json.loads(tool_call.function.arguments)
-                logger.debug(f"calling %s with args %s", tool_name, arguments)
-
-                tool = next((tool for tool in self.tools if tool.name == tool_name), None)
-                if tool is None:
-                    raise Exception(f"No tool found with name {tool_name}")
-
-                tool_calls.append(ToolCall(name=tool_name, arguments=arguments))
-                tool_outputs.append({
-                    "tool_call_id": tool_call.id,
-                    "output": tool.action(**arguments),
-                })
-
-            run = self.client.beta.threads.runs.submit_tool_outputs_and_poll(
-                thread_id=thread.id,
-                run_id=run.id,
-                tool_outputs=tool_outputs,
-            )
+        messages: ResponseInputParam = [
+            EasyInputMessageParam(role="system", content=self.instructions),
+            EasyInputMessageParam(role="user", content=question)
+        ]
+
+        response: Response = self.client.responses.create(model=self.model, input=messages, tools=self.tool_params)
+
+        while response.output_text == "":
+            for tool_call in response.output:
+                if not isinstance(tool_call, ResponseFunctionToolCall):
+                    continue
+                new_messages = self.invoke_tool(tool_call)
+                messages.extend(new_messages)
+
+            response = self.client.responses.create(model=self.model, input=messages, tools=self.tool_params)
 
-        messages = self.client.beta.threads.messages.list(thread_id=thread.id)
-        return AgentResult(
-            response=messages.data[0].content[0].text.value,
-            tool_calls=tool_calls,
-        )
+        tool_calls = [
+            ToolCall(name=message["name"], arguments=json.loads(message["arguments"]))
+            for message in messages if "type" in message and message["type"] == "function_call"
+        ]
+
+        return AgentResult(response=response.output_text, tool_calls=tool_calls)
+
+    def invoke_tool(self, tool_call: ResponseFunctionToolCall) -> ResponseInputParam:
+        arguments = json.loads(tool_call.arguments)
+        logger.debug(f"calling %s with args %s", tool_call.name, arguments)
+        tool = next((tool for tool in self.tools if tool.name == tool_call.name), None)
+        if tool is None:
+            raise Exception(f"No tool found with name {tool_call.name}")
+
+        return [
+            ResponseFunctionToolCallParam(
+                id=tool_call.id,
+                arguments=tool_call.arguments,
+                call_id=tool_call.call_id,
+                name=tool_call.name,
+                type="function_call",
+            ),
+            FunctionCallOutput(
+                call_id=tool_call.call_id,
+                output=tool.invoke(**arguments),
+                type="function_call_output",
+            )
+        ]

discovery/agent_support/tool.py

@@ -2,6 +2,8 @@
 from typing import Callable, List
 from inspect import signature, Parameter
 
+from openai.types.responses import FunctionToolParam
+
 
 @dataclass
 class Argument:
@@ -14,25 +16,25 @@ class Argument:
 class Tool:
     name: str
     description: str
-    action: Callable
+    invoke: Callable
     arguments: List[Argument]
 
-    def schema(self) -> dict:
-        return {
-            "type": "function",
-            "function": {
-                "name": self.name,
-                "description": self.description,
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        argument.name: {"type": argument.type}
-                        for argument in self.arguments
-                    },
-                    "required": [argument.name for argument in self.arguments if argument.required],
-                }
-            }
-        }
+    def tool_param(self) -> FunctionToolParam:
+        return FunctionToolParam(
+            name=self.name,
+            parameters={
+                "type": "object",
+                "properties": {
+                    argument.name: {"type": argument.type}
+                    for argument in self.arguments
+                },
+                "required": [argument.name for argument in self.arguments if argument.required],
+                "additionalProperties": False,
+            },
+            strict=False,
+            type="function",
+            description=self.description,
+        )
 
 
 def json_type(parameter: Parameter) -> str:
@@ -67,7 +69,7 @@ def wrapper(action: Callable) -> Tool:
         return Tool(
             name=action.__name__,
             description=action.__doc__,
-            action=action,
+            invoke=action,
             arguments=[argument_from_parameter(parameter) for parameter in parameters]
         )
 

discovery/repository_agent/repository_agent.py

@@ -11,7 +11,7 @@ def repository_agent_creator(open_ai_client: OpenAI) -> Callable[[GithubClient],
     return lambda github_client: Agent(
         client=open_ai_client,
         model="gpt-4o-mini",
-        instructions="""
+        system_instructions="""
             You are a helpful assistant that can answer a user's questions about GitHub Repositories.
             Use the provided functions to answer the user's questions.
             When possible, prefer to use search functions over list functions to find lists of repositories matching certain

tests/agent_support/test_agent.py

@@ -9,7 +9,7 @@
 
 
 @tool()
-def get_temperature(city: str) -> str:
+def get_temperature(city: str, unrelated: str = "") -> str:
     """Gets the temperature for a given city"""
     return "86"
 
@@ -19,7 +19,7 @@ def test_answer(self):
         agent = Agent(
             client=OpenAI(api_key=require_env("OPEN_AI_KEY")),
             model="gpt-4o",
-            instructions="You are a helpful assistant that can answer questions about weather. "
+            system_instructions="You are a helpful assistant that can answer questions about weather. "
                          "Use the only the functions provided to answer the user's question."
                          "You must always use the provided function.",
             tools=[get_temperature],

tests/agent_support/test_tool.py

@@ -1,5 +1,7 @@
 import unittest
 
+from openai.types.responses import FunctionToolParam
+
 from discovery.agent_support.tool import tool, Argument
 
 
@@ -8,31 +10,32 @@ def some_tool(username: str, count: int, done: bool = False) -> str:
     """A helpful description"""
     return f"Hello {username}, {count}, {done}"
 
+
 class TestTool(unittest.TestCase):
     def test_tool_attributes(self):
         self.assertEqual("some_tool", some_tool.name)
         self.assertEqual("A helpful description", some_tool.description)
-        self.assertEqual("Hello fred, 3, True", some_tool.action("fred", 3, True))
+        self.assertEqual("Hello fred, 3, True", some_tool.invoke("fred", 3, True))
         self.assertEqual([
             Argument(name="username", type="string", required=True),
             Argument(name="count", type="number", required=True),
             Argument(name="done", type="boolean", required=False),
         ], some_tool.arguments)
 
     def test_tool_schema(self):
-        self.assertEqual({
-            "type": "function",
-            "function": {
-                "name": "some_tool",
-                "description": "A helpful description",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "username": {"type": "string"},
-                        "count": {"type": "number"},
-                        "done": {"type": "boolean"},
-                    },
-                    "required": ["username", "count"],
-                }
+        self.assertEqual(FunctionToolParam(
+            type="function",
+            name="some_tool",
+            strict=False,
+            description="A helpful description",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "username": {"type": "string"},
+                    "count": {"type": "number"},
+                    "done": {"type": "boolean"},
+                },
+                "required": ["username", "count"],
+                'additionalProperties': False,
             }
-        }, some_tool.schema())
+        ), some_tool.tool_param())

tests/repository_agent/test_repository_agent.py

@@ -115,9 +115,9 @@ def test_list_repository_languages(self):
             responses.GET,
             "https://api.github.com/repos/pickles_org/pickles_repo/languages",
             json={
-                "python": 100,
-                "html": 50,
-                "css": 50,
+                "Python": 100,
+                "HTML": 50,
+                "CSS": 50,
             },
             status=200,
         )
@@ -129,10 +129,7 @@ def test_list_repository_languages(self):
         self.assertIn("CSS", result.response)
         self.assertNotIn("java", result.response)
         self.assertEqual(
-            [ToolCall(
-                name='list_repository_languages',
-                arguments={'full_name': 'pickles_org/pickles_repo'}
-            )],
+            [ToolCall(name='list_repository_languages', arguments={'full_name': 'pickles_org/pickles_repo'})],
             result.tool_calls
         )
 
@@ -143,19 +140,18 @@ def test_list_repository_contributors(self):
             responses.GET,
             "https://api.github.com/repos/pickles_org/pickles_repo/contributors",
             json=[
-                {"login": "fred"},
-                {"login": "mary"},
-                {"login": "kate"},
+                {"login": "Fred"},
+                {"login": "Mary"},
+                {"login": "Kate"},
             ],
             status=200,
         )
 
         result = self.agent.answer("Who contributes to the pickles_repo within the pickles_org?")
 
-        self.assertIn("fred", result.response)
-        self.assertIn("mary", result.response)
-        self.assertIn("kate", result.response)
-        self.assertNotIn("chuck", result.response)
+        self.assertIn("Fred", result.response)
+        self.assertIn("Mary", result.response)
+        self.assertIn("Kate", result.response)
         self.assertEqual(
             [ToolCall(
                 name='list_repository_contributors',