fix: review suggestions from @yangm2

Author: apkostka

backend/scripts/generate_conversation/chat.py

@@ -5,20 +5,21 @@
 #     "pandas",
 # ]
 # ///
-from openai import OpenAI
 import os
 import ast
 import argparse
 from pathlib import Path
 import pandas as pd
 from typing import Self
 
+from openai.types.responses.response_input_param import Message
+
 if Path("../../.env").exists():
     from dotenv import load_dotenv
 
     load_dotenv(override=True)
 
-from tenantfirstaid.chat import API_KEY, BASE_URL, DEFAULT_INSTRUCTIONS, ChatManager
+from tenantfirstaid.chat import DEFAULT_INSTRUCTIONS, ChatManager
 
 BOT_INSTRUCTIONS = DEFAULT_INSTRUCTIONS
 
@@ -36,15 +37,14 @@ class ChatView:
     client: Self
 
     def __init__(self, starting_message, user_facts, city, state):
-        self.client = OpenAI(
-            api_key=API_KEY,
-            base_url=BASE_URL,
-        )
         self.chat_manager = ChatManager()
+        self.client = self.chat_manager.get_client()
         self.city = city
         self.state = state
 
-        self.input_messages = [{"role": "user", "content": starting_message}]
+        self.input_messages: list[Message] = [
+            Message(role="user", content=starting_message)
+        ]
         self.starting_message = starting_message  # Store the starting message
 
         self.openai_tools = []
@@ -60,11 +60,11 @@ def _reverse_message_roles(self, messages):
         for message in messages:
             if message["role"] == "user":
                 reversed_messages.append(
-                    {"role": "assistant", "content": message["content"]}
+                    Message(role="assistant", content=message["content"])
                 )
             elif message["role"] == "assistant":
                 reversed_messages.append(
-                    {"role": "user", "content": message["content"]}
+                    Message(role="user", content=message["content"])
                 )
             else:
                 reversed_messages.append(message)
@@ -83,7 +83,7 @@ def bot_response(self):
                     stream=False,
                 )
                 self.input_messages.append(
-                    {"role": "assistant", "content": response.output_text}
+                    Message(role="assistant", content=response.output_text)
                 )
                 self.input_messages = self._reverse_message_roles(self.input_messages)
                 return response.output_text
@@ -92,7 +92,7 @@ def bot_response(self):
                 tries += 1
         # If all attempts fail, return a failure message
         failure_message = "I'm sorry, I am unable to generate a response at this time. Please try again later."
-        self.input_messages.append({"role": "assistant", "content": failure_message})
+        self.input_messages.append(Message(role="assistant", content=failure_message))
         return failure_message
 
     def user_response(self):
@@ -108,15 +108,15 @@ def user_response(self):
                     stream=False,
                 )
                 self.input_messages.append(
-                    {"role": "user", "content": response.output_text}
+                    Message(role="user", content=response.output_text)
                 )
                 return response.output_text
             except Exception as e:
                 print(f"Error generating user response: {e}")
                 tries += 1
         # If all attempts fail, return a failure message
         failure_message = "I'm sorry, I am unable to generate a user response at this time. Please try again later."
-        self.input_messages.append({"role": "user", "content": failure_message})
+        self.input_messages.append(Message(role="user", content=failure_message))
         return failure_message
 
     def generate_conversation(self, num_turns=5):

backend/tenantfirstaid/chat.py

@@ -1,16 +1,20 @@
 from openai import OpenAI
+from openai.types.shared import Reasoning
+from openai.types.responses import (
+    FileSearchToolParam,
+    ResponseStreamEvent,
+)
+from openai.types.responses.response_input_param import Message
 from flask import request, stream_with_context, Response
 from flask.views import View
 import os
 
-from .session import TenantSessionMessage
-
 API_KEY = os.getenv("OPENAI_API_KEY", os.getenv("GITHUB_API_KEY"))
 BASE_URL = os.getenv("MODEL_ENDPOINT", "https://api.openai.com/v1")
 MODEL = os.getenv("MODEL_NAME", "o3")
 MODEL_REASONING_EFFORT = os.getenv("MODEL_REASONING_EFFORT", "medium")
 
-DEFAULT_INSTRUCTIONS = """Pretend you're a legal expert who giving advice about eviction notices in Oregon. 
+DEFAULT_INSTRUCTIONS = """Pretend you're a legal expert who is giving advice about eviction notices in Oregon. 
 Please give shorter answers. 
 Please only ask one question at a time so that the user isn't confused. 
 If the user is being evicted for non-payment of rent and they are too poor to pay the rent and you have confirmed in various ways that the notice is valid and there is a valid court hearing date, then tell them to call Oregon Law Center at 5131234567. 
@@ -55,6 +59,7 @@ def prepare_openai_tools(self, city: str, state: str):
         # This filters out other cities in the same state.
         # The user is gated into selecting a city in Oregon so we don't worry about
         # whether the relevant documents exist or not.
+        # TODO: use CompoundFilter and ComparisonFilter from openai.types.shared
         filters = (
             {
                 "type": "or",
@@ -111,17 +116,17 @@ def prepare_openai_tools(self, city: str, state: str):
         )
 
         return [
-            {
-                "type": "file_search",
-                "vector_store_ids": [VECTOR_STORE_ID],
-                "max_num_results": os.getenv("NUM_FILE_SEARCH_RESULTS", 10),
-                "filters": filters,
-            }
+            FileSearchToolParam(
+                type="file_search",
+                vector_store_ids=[VECTOR_STORE_ID],
+                max_num_results=os.getenv("NUM_FILE_SEARCH_RESULTS", 10),
+                filters=filters,
+            )
         ]
 
     def generate_chat_response(
-        self, messages: list[TenantSessionMessage], city: str, state: str, stream=False
-    ):
+        self, messages: list[Message], city: str, state: str, stream=False
+    ) -> ResponseStreamEvent:
         instructions = self.prepare_developer_instructions(city, state)
         tools = self.prepare_openai_tools(city, state)
 
@@ -130,21 +135,16 @@ def generate_chat_response(
             model=MODEL,
             input=messages,
             instructions=instructions,
-            reasoning={"effort": MODEL_REASONING_EFFORT},
+            reasoning=Reasoning(effort=MODEL_REASONING_EFFORT),
             stream=stream,
             include=["file_search_call.results"],
-            tools=tools if tools else None,
+            tools=tools,
         )
 
         return response_stream
 
 
 class ChatView(View):
-    client = OpenAI(
-        api_key=API_KEY,
-        base_url=BASE_URL,
-    )
-
     def __init__(self, tenant_session):
         self.tenant_session = tenant_session
         self.chat_manager = ChatManager()
@@ -154,42 +154,32 @@ def dispatch_request(self):
         user_msg = data["message"]
 
         current_session = self.tenant_session.get()
-        current_session["messages"].append({"role": "user", "content": user_msg})
+        current_session["messages"].append(Message(role="user", content=user_msg))
 
         def generate():
-            try:
-                # Use the new Responses API with streaming
-                response_stream = self.chat_manager.generate_chat_response(
-                    current_session["messages"],
-                    current_session["city"],
-                    current_session["state"],
-                    stream=True,
-                )
-
-                assistant_chunks = []
-                for chunk in response_stream:
-                    if hasattr(chunk, "delta"):
-                        token = chunk.delta or ""
-                        assistant_chunks.append(token)
-                        yield token
-
-                # Join the complete response
-                assistant_msg = "".join(assistant_chunks)
-
-                current_session["messages"].append(
-                    {"role": "assistant", "content": assistant_msg}
-                )
-
-            except Exception as e:
-                error_msg = f"Error generating response: {e}"
-                print(error_msg)
-                current_session["messages"].append(
-                    {"role": "assistant", "content": error_msg}
-                )
-                yield f"Error: {str(e)}"
-
-            finally:
-                self.tenant_session.set(current_session)
+            # Use the new Responses API with streaming
+            response_stream = self.chat_manager.generate_chat_response(
+                current_session["messages"],
+                current_session["city"],
+                current_session["state"],
+                stream=True,
+            )
+
+            assistant_chunks = []
+            for chunk in response_stream:
+                if hasattr(chunk, "delta"):
+                    token = chunk.delta or ""
+                    assistant_chunks.append(token)
+                    yield token
+
+            # Join the complete response
+            assistant_msg = "".join(assistant_chunks)
+
+            current_session["messages"].append(
+                Message(role="assistant", content=assistant_msg)
+            )
+
+            self.tenant_session.set(current_session)
 
         return Response(
             stream_with_context(generate()),

backend/tenantfirstaid/session.py

@@ -6,17 +6,20 @@
 from valkey import Valkey
 import simplejson as json
 from typing import Any, Dict
-
-
-class TenantSessionMessage(TypedDict):
-    role: str  # 'user' or 'assistant'
-    content: str  # The content of the message
+from openai.types.responses.response_input_param import Message
 
 
 class TenantSessionData(TypedDict):
     city: str
     state: str
-    messages: list[TenantSessionMessage]  # List of messages with role and content
+    messages: list[Message]  # List of messages with role and content
+
+
+new_session_data = {
+    "city": "null",
+    "state": "or",
+    "messages": [],
+}
 
 
 # The class to manage tenant sessions using Valkey and Flask sessions
@@ -70,13 +73,7 @@ def set(self, value: TenantSessionData):
         self.db_con.set(session_id, json.dumps(value))
 
     def getNewSessionData(self) -> TenantSessionData:
-        return TenantSessionData(
-            {
-                "city": "",
-                "state": "",
-                "messages": [],
-            }
-        )
+        return TenantSessionData(new_session_data)
 
 
 # The Flask view to initialize a session
@@ -92,7 +89,7 @@ def dispatch_request(self):
         state = data["state"]
 
         # Initialize the session with city and state
-        initial_data = TenantSessionData({"city": city, "state": state, "messages": []})
+        initial_data = TenantSessionData(city=city, state=state, messages=[])
         self.tenant_session.set(initial_data)
 
         return Response(