fix: get rid of custom cache

app.py

@@ -2,22 +2,22 @@ import gradio as gr
 import json
 import os
 import numexpr
-import uuid
 from groq import Groq
 from groq.types.chat.chat_completion_tool_param import ChatCompletionToolParam
 
 MODEL = "llama3-groq-8b-8192-tool-use-preview"
 client = Groq(api_key=os.environ["GROQ_API_KEY"])
 
+
 def evaluate_math_expression(expression: str):
     return json.dumps(numexpr.evaluate(expression).tolist())
 
+
 calculator_tool: ChatCompletionToolParam = {
     "type": "function",
     "function": {
         "name": "evaluate_math_expression",
-        "description":
-        "Calculator tool: use this for evaluating numeric expressions with Python. Ensure the expression is valid Python syntax (e.g., use '**' for exponentiation, not '^').",
+        "description": "Calculator tool: use this for evaluating numeric expressions with Python. Ensure the expression is valid Python syntax (e.g., use '**' for exponentiation, not '^').",
         "parameters": {
             "type": "object",
             "properties": {
@@ -33,6 +33,7 @@ calculator_tool: ChatCompletionToolParam = {
 
 tools = [calculator_tool]
 
+
 def call_function(tool_call, available_functions):
     function_name = tool_call.function.name
     if function_name not in available_functions:
@@ -51,11 +52,35 @@ def call_function(tool_call, available_functions):
         "content": json.dumps(function_response),
     }
 
-def get_model_response(messages):
+
+def get_model_response(messages, inner_messages, message, system_message):
+    messages_for_model = []
+    for msg in messages:
+        native_messages = msg.get("metadata", {}).get("native_messages", [msg])
+        if isinstance(native_messages, list):
+            messages_for_model.extend(native_messages)
+        else:
+            messages_for_model.append(native_messages)
+
+    messages_for_model.insert(
+        0,
+        {
+            "role": "system",
+            "content": system_message,
+        },
+    )
+    messages_for_model.append(
+        {
+            "role": "user",
+            "content": message,
+        }
+    )
+    messages_for_model.extend(inner_messages)
+
     try:
         return client.chat.completions.create(
             model=MODEL,
-            messages=messages,
+            messages=messages_for_model,
             tools=tools,
             temperature=0.5,
             top_p=0.65,
@@ -63,70 +88,107 @@ def get_model_response(messages):
         )
     except Exception as e:
         print(f"An error occurred while getting model response: {str(e)}")
-        print(messages)
+        print(messages_for_model)
         return None
 
-conversation_state = {}
 
 def respond(message, history, system_message):
-    if not history or not isinstance(history[0][0], str):
-        session_id = str(uuid.uuid4())
-        history.insert(0, (session_id, "Confirmed."))
-    else:
-        session_id = history[0][0]
-
-    if session_id not in conversation_state:
-        conversation_state[session_id] = []
-
-    if len(conversation_state[session_id]) == 0:
-        conversation_state[session_id].append({"role": "system", "content": system_message})
-
-    conversation_state[session_id].append({"role": "user", "content": message})
+    inner_history = []
 
     available_functions = {
         "evaluate_math_expression": evaluate_math_expression,
     }
 
-    function_calls = []
+    assistant_content = ""
+    assistant_native_message_list = []
+
     while True:
-        response = get_model_response(conversation_state[session_id])
-        response_message = response.choices[0].message
-        conversation_state[session_id].append(response_message)
+        response_message = (
+            get_model_response(history, inner_history, message, system_message)
+            .choices[0]
+            .message
+        )
 
         if not response_message.tool_calls and response_message.content is not None:
             break
 
         if response_message.tool_calls is not None:
+            assistant_native_message_list.append(response_message)
+            inner_history.append(response_message)
+
+            assistant_content += (
+                "```json\n"
+                + json.dumps(
+                    [
+                        tool_call.model_dump()
+                        for tool_call in response_message.tool_calls
+                    ],
+                    indent=2,
+                )
+                + "\n```\n"
+            )
+            assistant_message = {
+                "role": "assistant",
+                "content": assistant_content,
+                "metadata": {"native_messages": assistant_native_message_list},
+            }
+
+            yield assistant_message
+
             for tool_call in response_message.tool_calls:
-                function_call = {
-                    "name": tool_call.function.name,
-                    "arguments": json.loads(tool_call.function.arguments)
-                }
-                function_calls.append(function_call)
                 function_response = call_function(tool_call, available_functions)
-                conversation_state[session_id].append(function_response)
-                function_calls.append({
-                    "name": function_response["name"],
-                    "result": json.loads(function_response["content"])
-                })
+                assistant_content += (
+                    "```json\n"
+                    + json.dumps(
+                        {
+                            "name": tool_call.function.name,
+                            "arguments": json.loads(tool_call.function.arguments),
+                            "response": json.loads(function_response["content"]),
+                        },
+                        indent=2,
+                    )
+                    + "\n```\n"
+                )
+                native_tool_message = {
+                    "tool_call_id": tool_call.id,
+                    "role": "tool",
+                    "content": function_response["content"],
+                }
+                assistant_native_message_list.append(
+                    native_tool_message
+                )
+                tool_message = {
+                    "role": "assistant",
+                    "content": assistant_content,
+                    "metadata": {"native_messages": assistant_native_message_list},
+                }
+                yield tool_message
+                inner_history.append(native_tool_message)
 
-    function_calls_md = "\n\n"
-    for i in range(0, len(function_calls), 2):
-        call = function_calls[i]
-        result = function_calls[i + 1] if i + 1 < len(function_calls) else None
-        function_calls_md += f"**Tool call:**\n```json\n{json.dumps({'name': call['name'], 'arguments': call['arguments'], 'result': result['result'] if result else None}, indent=2)}\n```\n"
+    assistant_content += response_message.content
+    assistant_native_message_list.append(response_message)
 
-    return response_message.content + function_calls_md
+    final_message = {
+        "role": "assistant",
+        "content": assistant_content,
+        "metadata": {"native_messages": assistant_native_message_list},
+    }
+    
+    yield final_message
 
 
 demo = gr.ChatInterface(
     respond,
     additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot with access to a calculator. Don't mention that we are using functions defined in Python.", label="System message"),
+        gr.Textbox(
+            value="You are a friendly Chatbot with access to a calculator. Don't mention that we are using functions defined in Python.",
+            label="System message",
+        ),
     ],
+    type="messages",
     title="Groq Tool Use Chat",
     description="This chatbot uses the `llama3-groq-8b-8192-tool-use-preview` LLM with tool use capabilities, including a calculator function.",
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()