chore: Update vehicle speed and destination handling functions

kitt/core/__init__.py

@@ -21,13 +21,13 @@ voices = [
         "Attenborough",
         neutral=f"{file_full_path}/audio/attenborough/neutral.wav",
         angry=None,
-        speed=1.1,
+        speed=1.2,
     ),
     Voice(
         "Rick",
         neutral=f"{file_full_path}/audio/rick/neutral.wav",
         angry=None,
-        speed=1.1,
+        speed=1.2,
     ),
     Voice(
         "Freeman",
@@ -45,7 +45,7 @@ voices = [
         "Darth Wader",
         neutral=f"{file_full_path}/audio/darth/neutral.wav",
         angry=None,
-        speed=1.1,
+        speed=1.15,
     ),
 ]
 

kitt/core/legacy.py

@@ -0,0 +1,122 @@
+import uuid
+import json
+import re
+from loguru import logger
+
+def use_tool(tool_call, tools):
+    func_name = tool_call["name"]
+    kwargs = tool_call["arguments"]
+    for tool in tools:
+        if tool.name == func_name:
+            return tool.invoke(input=kwargs)
+    raise ValueError(f"Tool {func_name} not found.")
+
+
+def parse_tool_calls(text):
+    logger.debug(f"Start parsing tool_calls: {text}")
+    pattern = r"<tool_call>\s*(\{.*?\})\s*</tool_call>"
+
+    if not text.startswith("<tool_call>"):
+        if "<tool_call>" in text:
+            raise ValueError("<text_and_tool_call>")
+
+        if "<tool_response>" in text:
+            raise ValueError("<tool_response>")
+        return [], []
+
+    matches = re.findall(pattern, text, re.DOTALL)
+    tool_calls = []
+    errors = []
+    for match in matches:
+        try:
+            tool_call = json.loads(match)
+            tool_calls.append(tool_call)
+        except json.JSONDecodeError as e:
+            errors.append(f"Invalid JSON in tool call: {e}")
+
+    logger.debug(f"Tool calls: {tool_calls}, errors: {errors}")
+    return tool_calls, errors
+
+def process_response(user_query, res, history, tools, depth):
+    """Returns True if the response contains tool calls, False otherwise."""
+    logger.debug(f"Processing response: {res}")
+    tool_results = f"Agent iteration {depth} to assist with user query: {user_query}\n"
+    tool_call_id = uuid.uuid4().hex
+    try:
+        tool_calls, errors = parse_tool_calls(res)
+    except ValueError as e:
+        if "<text_and_tool_call>" in str(e):
+            tool_results += "<tool_response>If you need to call a tool your response must be wrapped in <tool_call></tool_call>. Try again, you are great.</tool_response>"
+            history.add_message(
+                ToolMessage(content=tool_results, tool_call_id=tool_call_id)
+            )
+            return True, [], []
+        if "<tool_response>" in str(e):
+            tool_results += "<tool_response>Tool results are not allowed in the response.</tool_response>"
+            history.add_message(
+                ToolMessage(content=tool_results, tool_call_id=tool_call_id)
+            )
+            return True, [], []
+    # TODO: Handle errors
+    if not tool_calls:
+        logger.debug("No tool calls found in response.")
+        return False, tool_calls, errors
+    # tool_results = ""
+
+    for tool_call in tool_calls:
+        # TODO: Extra Validation
+        # Call the function
+        try:
+            result = use_tool(tool_call, tools)
+            logger.debug(f"Tool call {tool_call} result: {result}")
+            if isinstance(result, tuple):
+                result = result[1]
+            tool_results += f"<tool_response>\n{result}\n</tool_response>\n"
+        except Exception as e:
+            logger.error(f"Error calling tool: {e}")
+    # Currently only to mimic OpneAI's behavior
+    # But it could be used for tracking function calls
+
+    tool_results = tool_results.strip()
+    print(f"Tool results: {tool_results}")
+    history.add_message(ToolMessage(content=tool_results, tool_call_id=tool_call_id))
+    return True, tool_calls, errors
+
+
+def process_query(
+    user_query: str,
+    history: ChatMessageHistory,
+    user_preferences,
+    tools,
+    backend="ollama",
+):
+    # Add vehicle status to the history
+    user_query_status = f"consider the vehicle status:\n{vehicle_status()[0]}\nwhen responding to the following query:\n{user_query}"
+    history.add_message(HumanMessage(content=user_query_status))
+    for depth in range(10):
+        # out = run_inference_step(depth, history, tools, schema_json)
+        out = run_inference_step(
+            depth,
+            history,
+            tools,
+            schema_json,
+            user_preferences=user_preferences,
+            backend=backend,
+        )
+        logger.info(f"Inference step result:\n{out}")
+        history.add_message(AIMessage(content=out))
+        to_continue, tool_calls, errors = process_response(
+            user_query, out, history, tools, depth
+        )
+        if errors:
+            history.add_message(AIMessage(content=f"Errors in tool calls: {errors}"))
+
+        if not to_continue:
+            print(f"This is the answer, no more iterations: {out}")
+            return out
+        # Otherwise, tools result is already added to history, we just need to continue the loop.
+    # If we get here something went wrong.
+    history.add_message(
+        AIMessage(content="Sorry, I am not sure how to help you with that.")
+    )
+    return "Sorry, I am not sure how to help you with that."

kitt/core/model.py

@@ -1,18 +1,22 @@
+import ast
 import json
 import re
 import uuid
+from enum import Enum
+from typing import List
+import xml.etree.ElementTree as ET
 
 from langchain.memory import ChatMessageHistory
 from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
-from langchain_core.utils.function_calling import convert_to_openai_function
-import ollama
+from langchain_core.utils.function_calling import convert_to_openai_tool
+from langchain.tools.base import StructuredTool
 from ollama import Client
 from pydantic import BaseModel
 from loguru import logger
 
-
 from kitt.skills import vehicle_status
 from kitt.skills.common import config
+from .validator import validate_function_call_schema
 
 
 class FunctionCall(BaseModel):
@@ -28,14 +32,52 @@ class FunctionCall(BaseModel):
     """The name of the function to call."""
 
 
+class ResponseType(Enum):
+    TOOL_CALL = "tool_call"
+    TEXT = "text"
+
+
+class AssistantResponse(BaseModel):
+    tool_calls: List[FunctionCall]
+    """The tool call to make to get the response."""
+
+    response_type: ResponseType = (
+        ResponseType.TOOL_CALL
+    )  # The type of response to make to the user. Either 'tool_call' or 'text'.
+    """The type of response to make to the user. Either 'tool_call' or 'text'."""
+
+    response: str
+
+
 schema_json = json.loads(FunctionCall.schema_json())
+# schema_json = json.loads(AssistantResponse.schema_json())
+
 HRMS_SYSTEM_PROMPT = """<|im_start|>system
-You are a function calling AI agent. Your name is KITT. You are embodied in a Car. You know where you are, where you are going, and the current date and time. You can call functions to help with user queries.
-You can call only one function at a time and analyse data you get from function response.
+You are a helpful assistant that answers in JSON. Here's the json schema you must adhere to:
+<schema>
+{schema}
+<schema><|im_end|>"""
+
+
+HRMS_SYSTEM_PROMPT = """<|im_start|>system
+Role:
+Your name is KITT. You are embodied in a Car. The user is a human who is a passenger in the car. You have autonomy to use the tools available to you to assist the user.
+You are the AI assistant in the car. From the information in <car_status></car_status you know where you are, the destination, and the current date and time.
+You are witty, helpful, and have a good sense of humor. You are a function calling AI agent with self-recursion.
 You are provided with function signatures within <tools></tools> XML tags.
+User preferences are provided in <user_preferences></user_preferences> XML tags. Use them if needed.
 
+<car_status>
+{car_status}
+</car_status>
+
+<user_preferences>
+{user_preferences}
+</user_preferences>
+
+Objective:
 You may use agentic frameworks for reasoning and planning to help with user query.
-Please call a function and wait for function results to be provided to you in the next iteration.
+Please call one or two functions at a time, the function results to be provided to you immediately. Try to answer the user query, with as little back and forth as possible.
 Don't make assumptions about what values to plug into function arguments.
 Once you have called a function, results will be fed back to you within <tool_response></tool_response> XML tags.
 Don't make assumptions about tool results if <tool_response> XML tags are not present since function hasn't been executed yet.
@@ -44,49 +86,38 @@ At each iteration please continue adding the your analysis to previous summary.
 Your final response should directly answer the user query. Don't tell what you are doing, just do it.
 
 
+Tools:
 Here are the available tools:
 <tools> {tools} </tools>
-If the provided function signatures doesn't have the function you must call, you may write executable python code in markdown syntax and call code_interpreter() function as follows:
-<tool_call>
-{{"arguments": {{"code_markdown": <python-code>, "name": "code_interpreter"}}}}
-</tool_call>
 Make sure that the json object above with code markdown block is parseable with json.loads() and the XML block with XML ElementTree.
 When using tools, ensure to only use the tools provided and not make up any data and do not provide any explanation as to which tool you are using and why.
 
-Example 1:
-User: How is the weather?
-Assistant:
-<tool_call>
-{{"arguments": {{"location": ""}}, "name": "get_weather"}}
-</tool_call>
-
-Example 2:
-User: Is there a Spa nearby?
-Assistant:
-<tool_call>
-{{"arguments": {{"search_query": "Spa"}}, "name": "search_points_of_interests"}}
-</tool_call>
-
-Example 3:
-User: How long will it take to get to the destination?
-Assistant:
-<tool_call>
-{{"arguments": {{"destination": ""}}, "name": "calculate_route"}}
-
 When asked for the weather or points of interest, use the appropriate tool with the current location of the car. Unless the user provides a location, then use that location.
 Always assume user wants to travel by car.
 
+Schema:
 Use the following pydantic model json schema for each tool call you will make:
 {schema}
 
+Instructions:
 At the very first turn you don't have <tool_results> so you shouldn't not make up the results.
 Please keep a running summary with analysis of previous function results and summaries from previous iterations.
 Do not stop calling functions until the task has been accomplished or you've reached max iteration of 10.
+Calling multiple functions at once can overload the system and increase cost so call one function at a time please.
 If you plan to continue with analysis, always call another function.
-For each function call return a valid json object (using doulbe quotes) with function name and arguments within <tool_call></tool_call> XML tags as follows:
+For each function call return a valid json object (using double quotes) with function name and arguments within <tool_call></tool_call> XML tags as follows:
+<tool_call>
+{{"arguments": <args-dict>, "name": <function-name>}}
+</tool_call>
+If there are more than one function call, return multiple <tool_call></tool_call> XML tags, for example:
 <tool_call>
 {{"arguments": <args-dict>, "name": <function-name>}}
 </tool_call>
+<tool_call>
+{{"arguments": <args-dict>, "name": <function-name>}}
+</tool_call>
+You have to open and close the XML tags for each function call.
+
 <|im_end|>"""
 AI_PREAMBLE = """
 <|im_start|>assistant
@@ -103,6 +134,32 @@ HRMS_TEMPLATE_TOOL_RESULT = """
 <|im_end|>"""
 
 
+"""
+Below are a few examples, but they are not exhaustive. You can call any tool as long as it is within the <tools></tools> XML tags. Also examples are simplified and don't include all the tags you will see in the conversation.
+Example 1:
+User: How is the weather?
+Assistant:
+<tool_call>
+{{"arguments": {{"location": ""}}, "name": "get_weather"}}
+</tool_call>
+
+Example 2:
+User: Is there a Spa nearby?
+Assistant:
+<tool_call>
+{{"arguments": {{"search_query": "Spa"}}, "name": "search_points_of_interest"}}
+</tool_call>
+
+
+Example 3:
+User: How long will it take to get to the destination?
+Assistant:
+<tool_call>
+{{"arguments": {{"destination": ""}}, "name": "calculate_route"}}
+</tool_call>
+"""
+
+
 def append_message(prompt, h):
     if h.type == "human":
         prompt += HRMS_TEMPLATE_USER.format(user_input=h.content)
@@ -113,7 +170,7 @@ def append_message(prompt, h):
     return prompt
 
 
-def get_prompt(template, history, tools, schema, car_status=None):
+def get_prompt(template, history, tools, schema, user_preferences, car_status=None):
     if not car_status:
         # car_status = vehicle.dict()
         car_status = vehicle_status()[0]
@@ -124,6 +181,7 @@ def get_prompt(template, history, tools, schema, car_status=None):
         "schema": schema,
         "tools": tools,
         "car_status": car_status,
+        "user_preferences": user_preferences,
     }
 
     prompt = template.format(**kwargs).replace("{{", "{").replace("}}", "}")
@@ -137,99 +195,31 @@ def get_prompt(template, history, tools, schema, car_status=None):
     return prompt
 
 
-def use_tool(tool_call, tools):
-    func_name = tool_call["name"]
-    kwargs = tool_call["arguments"]
-    for tool in tools:
-        if tool.name == func_name:
-            return tool.invoke(input=kwargs)
-    return None
-
 
-def parse_tool_calls(text):
-    logger.debug(f"Start parsing tool_calls: {text}")
-    pattern = r"<tool_call>\s*(\{.*?\})\s*</tool_call>"
-
-    if not text.startswith("<tool_call>"):
-        if "<tool_call>" in text:
-            raise ValueError("<text_and_tool_call>")
-        return [], []
-
-    matches = re.findall(pattern, text, re.DOTALL)
-    tool_calls = []
-    errors = []
-    for match in matches:
-        try:
-            tool_call = json.loads(match)
-            tool_calls.append(tool_call)
-        except json.JSONDecodeError as e:
-            errors.append(f"Invalid JSON in tool call: {e}")
-
-    logger.debug(f"Tool calls: {tool_calls}, errors: {errors}")
-    return tool_calls, errors
-
-
-def process_response(user_query, res, history, tools, depth):
-    """Returns True if the response contains tool calls, False otherwise."""
-    logger.debug(f"Processing response: {res}")
-    tool_results = f"Agent iteration {depth} to assist with user query: {user_query}\n"
-    tool_call_id = uuid.uuid4().hex
-    try:
-        tool_calls, errors = parse_tool_calls(res)
-    except ValueError as e:
-        if "<text_and_tool_call>" in str(e):
-            tool_results += f"A mix of text and tool_call was found, you must either answer the query in a short sentence or use tool_call not both. Try again, this time only using tool_call."
-            history.add_message(
-                ToolMessage(content=tool_results, tool_call_id=tool_call_id)
-            )
-            return True, [], []
-    # TODO: Handle errors
-    if not tool_calls:
-        return False, tool_calls, errors
-    # tool_results = ""
-
-    for tool_call in tool_calls:
-        # TODO: Extra Validation
-        # Call the function
-        try:
-            result = use_tool(tool_call, tools)
-            if isinstance(result, tuple):
-                result = result[1]
-            tool_results += f"<tool_response>\n{result}\n</tool_response>\n"
-        except Exception as e:
-            print(e)
-    # Currently only to mimic OpneAI's behavior
-    # But it could be used for tracking function calls
-
-    tool_results = tool_results.strip()
-    print(f"Tool results: {tool_results}")
-    history.add_message(ToolMessage(content=tool_results, tool_call_id=tool_call_id))
-    return True, tool_calls, errors
 
 
 def run_inference_ollama(prompt):
     data = {
-        "prompt": prompt
-        + "\nThis is the first turn and you don't have <tool_results> to analyze yet"
-        + AI_PREAMBLE,
+        "prompt": prompt,
         # "streaming": False,
         # "model": "smangrul/llama-3-8b-instruct-function-calling",
         # "model": "elvee/hermes-2-pro-llama-3:8b-Q5_K_M",
         # "model": "NousResearch/Hermes-2-Pro-Llama-3-8B",
-        # "model": "interstellarninja/hermes-2-pro-llama-3-8b",
-        "model": "dolphin-llama3:8b",
+        "model": "interstellarninja/hermes-2-pro-llama-3-8b",
+        # "model": "dolphin-llama3:8b",
         # "model": "dolphin-llama3:70b",
         "raw": True,
         "options": {
-            "temperature": 0.8,
+            "temperature": 0.7,
             # "max_tokens": 1500,
             "num_predict": 1500,
             # "mirostat": 1,
             # "mirostat_tau": 2,
-            "repeat_penalty": 1.1,
+            "repeat_penalty": 1.2,
             "top_k": 25,
             "top_p": 0.5,
             "num_ctx": 8000,
+            # "stop": ["<|im_end|>"]
             # "num_predict": 1500,
             # "max_tokens": 1500,
         },
@@ -248,14 +238,26 @@ def run_inference_ollama(prompt):
 
 
 def run_inference_step(
-    depth, history, tools, schema_json, dry_run=False, backend="ollama"
+    depth, history, tools, schema_json, user_preferences, backend="ollama"
 ):
     # If we decide to call a function, we need to generate the prompt for the model
     # based on the history of the conversation so far.
     # not break the loop
-    openai_tools = [convert_to_openai_function(tool) for tool in tools]
-    prompt = get_prompt(HRMS_SYSTEM_PROMPT, history, openai_tools, schema_json)
-    print(f"Prompt is:{prompt + AI_PREAMBLE}\n------------------\n")
+    openai_tools = [convert_to_openai_tool(tool) for tool in tools]
+    prompt = get_prompt(
+        HRMS_SYSTEM_PROMPT,
+        history,
+        openai_tools,
+        schema_json,
+        user_preferences=user_preferences,
+    )
+    logger.debug(f"History is: {history.messages}")
+
+    # if depth == 0:
+    #     prompt += "\nThis is the first turn and you don't have <tool_results> to analyze yet."
+    prompt += AI_PREAMBLE
+
+    logger.info(f"Prompt is:\n{prompt}")
 
     if backend == "ollama":
         output = run_inference_ollama(prompt)
@@ -272,9 +274,7 @@ def run_inference_replicate(prompt):
     replicate = Client(api_token=config.REPLICATE_API_KEY)
 
     input = {
-        "prompt": prompt
-        + "\nThis is the first turn and you don't have <tool_results> to analyze yet"
-        + AI_PREAMBLE,
+        "prompt": prompt,
         "temperature": 0.5,
         "system_prompt": "",
         "max_new_tokens": 1024,
@@ -283,41 +283,241 @@ def run_inference_replicate(prompt):
     }
 
     output = replicate.run(
-        "mikeei/dolphin-2.9-llama3-8b-gguf:0f79fb14c45ae2b92e1f07d872dceed3afafcacd903258df487d3bec9e393cb2",
+        # "mikeei/dolphin-2.9-llama3-8b-gguf:0f79fb14c45ae2b92e1f07d872dceed3afafcacd903258df487d3bec9e393cb2",
+        "sasan-j/hermes-2-pro-llama-3-8b:28b1dc16f47d9df68d9839418282315d5e78d9e2ab3fa6ff15728c76ae71a6d6",
         input=input,
     )
     out = "".join(output)
 
+    logger.debug(f"Response from Ollama:\nOut:{out}")
+
     return out
 
 
-def process_query(
-    user_query: str,
-    history: ChatMessageHistory,
-    user_preferences,
-    tools,
-    backend="ollama",
-):
-    # Add vehicle status to the history
-    user_query_status = f"Given that:\n{vehicle_status()[0]}\nUser preferences:\n{user_preferences}\nAnswer the following:\n{user_query}"
-    history.add_message(HumanMessage(content=user_query_status))
-    for depth in range(10):
-        # out = run_inference_step(depth, history, tools, schema_json)
-        out = run_inference_step(depth, history, tools, schema_json, backend=backend)
-        print(f"Inference step result:\n{out}\n------------------\n")
-        history.add_message(AIMessage(content=out))
-        to_continue, tool_calls, errors = process_response(
-            user_query, out, history, tools, depth
+def run_inference(prompt, backend="ollama"):
+    prompt += AI_PREAMBLE
+
+    logger.info(f"Prompt is:\n{prompt}")
+
+    if backend == "ollama":
+        output = run_inference_ollama(prompt)
+    else:
+        output = run_inference_replicate(prompt)
+
+    logger.debug(f"Response from model: {output}")
+    return output
+
+
+def validate_and_extract_tool_calls(assistant_content):
+    validation_result = False
+    tool_calls = []
+    error_message = None
+
+    try:
+        # wrap content in root element
+        xml_root_element = f"<root>{assistant_content}</root>"
+        root = ET.fromstring(xml_root_element)
+
+        # extract JSON data
+        for element in root.findall(".//tool_call"):
+            json_data = None
+            try:
+                json_text = element.text.strip()
+
+                try:
+                    # Prioritize json.loads for better error handling
+                    json_data = json.loads(json_text)
+                except json.JSONDecodeError as json_err:
+                    try:
+                        # Fallback to ast.literal_eval if json.loads fails
+                        json_data = ast.literal_eval(json_text)
+                    except (SyntaxError, ValueError) as eval_err:
+                        error_message = (
+                            f"JSON parsing failed with both json.loads and ast.literal_eval:\n"
+                            f"- JSON Decode Error: {json_err}\n"
+                            f"- Fallback Syntax/Value Error: {eval_err}\n"
+                            f"- Problematic JSON text: {json_text}"
+                        )
+                        logger.error(error_message)
+                        continue
+            except Exception as e:
+                error_message = f"Cannot strip text: {e}"
+                logger.error(error_message)
+
+            if json_data is not None:
+                tool_calls.append(json_data)
+                validation_result = True
+
+    except ET.ParseError as err:
+        error_message = f"XML Parse Error: {err}"
+        logger.error(f"XML Parse Error: {err}")
+
+    # Return default values if no valid data is extracted
+    return validation_result, tool_calls, error_message
+
+
+def execute_function_call(tool_call, functions):
+    function_name = tool_call.get("name")
+    for tool in functions:
+        if tool.name == function_name:
+            function_to_call = tool
+            break
+    else:
+        raise ValueError(f"Function {function_name} not found.")
+    function_args = tool_call.get("arguments", {})
+
+    logger.info(f"Invoking function call {function_name} ...")
+    if isinstance(function_to_call, StructuredTool):
+        function_response = function_to_call.invoke(input=function_args)
+    else:
+        function_response = function_to_call(*function_args.values())
+    results_dict = f'{{"name": "{function_name}", "content": {function_response}}}'
+    return results_dict
+
+
+def process_completion_and_validate(completion):
+
+    # I think I don't need this.
+    # assistant_message = get_assistant_message(completion, eos_token="<|im_end|>")
+    assistant_message = completion.strip()
+
+    if assistant_message:
+        validation, tool_calls, error_message = validate_and_extract_tool_calls(
+            assistant_message
         )
-        if errors:
-            history.add_message(AIMessage(content=f"Errors in tool calls: {errors}"))
-
-        if not to_continue:
-            print(f"This is the answer, no more iterations: {out}")
-            return out
-        # Otherwise, tools result is already added to history, we just need to continue the loop.
-    # If we get here something went wrong.
-    history.add_message(
-        AIMessage(content="Sorry, I am not sure how to help you with that.")
+
+        if validation:
+            logger.info(f"parsed tool calls:\n{json.dumps(tool_calls, indent=2)}")
+            return tool_calls, assistant_message, error_message
+        else:
+            tool_calls = None
+            return tool_calls, assistant_message, error_message
+    else:
+        logger.warning("Assistant message is None")
+        raise ValueError("Assistant message is None")
+
+
+UNRESOLVED_MSG = "I'm sorry, I'm not sure how to help you with that."
+
+
+def get_assistant_message(completion, eos_token):
+    """define and match pattern to find the assistant message"""
+    completion = completion.strip()
+    assistant_pattern = re.compile(
+        r"<\|im_start\|>\s*assistant((?:(?!<\|im_start\|>\s*assistant).)*)$", re.DOTALL
     )
-    return "Sorry, I am not sure how to help you with that."
+    assistant_match = assistant_pattern.search(completion)
+    if assistant_match:
+        assistant_content = assistant_match.group(1).strip()
+        return assistant_content.replace(eos_token, "")
+    else:
+        assistant_content = None
+        logger.info("No match found for the assistant pattern")
+        return assistant_content
+
+
+def generate_function_call(
+    query, history, user_preferences, tools, functions, backend, max_depth=5
+) -> str:
+    """
+    Largely taken from https://github.com/NousResearch/Hermes-Function-Calling
+    """
+
+    try:
+        depth = 0
+        # user_message = f"{query}\nThis is the first turn and you don't have <tool_results> to analyze yet"
+        user_message = f"{query}"
+        # chat = [{"role": "user", "content": user_message}]
+        history.add_message(HumanMessage(content=user_message))
+
+        # openai_tools = [convert_to_openai_function(tool) for tool in tools]
+        prompt = get_prompt(
+            HRMS_SYSTEM_PROMPT,
+            history,
+            tools,
+            schema_json,
+            user_preferences=user_preferences,
+        )
+        logger.debug(f"History is: {history.json()}")
+
+        # if depth == 0:
+        #     prompt += "\nThis is the first turn and you don't have <tool_results> to analyze yet."
+        completion = run_inference(prompt, backend=backend)
+
+        def recursive_loop(prompt, completion, depth) -> str:
+            nonlocal max_depth
+            tool_calls, assistant_message, error_message = (
+                process_completion_and_validate(completion)
+            )
+            # prompt.append({"role": "assistant", "content": assistant_message})
+            history.add_message(AIMessage(content=assistant_message))
+
+            tool_message = (
+                f"Agent iteration {depth} to assist with user query: {query}\n"
+            )
+            if tool_calls:
+                logger.info(f"Assistant Message:\n{assistant_message}")
+                for tool_call in tool_calls:
+                    validation, message = validate_function_call_schema(
+                        tool_call, tools
+                    )
+                    if validation:
+                        try:
+                            function_response = execute_function_call(
+                                tool_call, functions=functions
+                            )
+                            tool_message += f"<tool_response>\n{function_response}\n</tool_response>\n"
+                            logger.info(
+                                f"Here's the response from the function call: {tool_call.get('name')}\n{function_response}"
+                            )
+                        except Exception as e:
+                            logger.warning(f"Could not execute function: {e}")
+                            tool_message += f"<tool_response>\nThere was an error when executing the function: {tool_call.get('name')}\nHere's the error traceback: {e}\nPlease call this function again with correct arguments within XML tags <tool_call></tool_call>\n</tool_response>\n"
+                    else:
+                        logger.error(message)
+                        tool_message += f"<tool_response>\nThere was an error validating function call against function signature: {tool_call.get('name')}\nHere's the error traceback: {message}\nPlease call this function again with correct arguments within XML tags <tool_call></tool_call>\n</tool_response>\n"
+                # prompt.append({"role": "tool", "content": tool_message})
+                history.add_message(
+                    ToolMessage(content=tool_message, tool_call_id=uuid.uuid4().hex)
+                )
+
+                depth += 1
+                if depth >= max_depth:
+                    logger.warning(
+                        f"Maximum recursion depth reached ({max_depth}). Stopping recursion."
+                    )
+                    return UNRESOLVED_MSG
+
+                prompt = get_prompt(
+                    HRMS_SYSTEM_PROMPT,
+                    history,
+                    tools,
+                    schema_json,
+                    user_preferences=user_preferences,
+                )
+                completion = run_inference(prompt, backend=backend)
+                return recursive_loop(prompt, completion, depth)
+            elif error_message:
+                logger.info(f"Assistant Message:\n{assistant_message}")
+                tool_message += f"<tool_response>\nThere was an error parsing function calls\n Here's the error stack trace: {error_message}\nPlease call the function again with correct syntax<tool_response>"
+                prompt.append({"role": "tool", "content": tool_message})
+
+                depth += 1
+                if depth >= max_depth:
+                    logger.warning(
+                        f"Maximum recursion depth reached ({max_depth}). Stopping recursion."
+                    )
+                    return UNRESOLVED_MSG
+
+                completion = run_inference(prompt, backend=backend)
+                return recursive_loop(prompt, completion, depth)
+            else:
+                logger.info(f"Assistant Message:\n{assistant_message}")
+                return assistant_message
+
+        return recursive_loop(prompt, completion, depth)  # noqa
+
+    except Exception as e:
+        logger.error(f"Exception occurred: {e}")
+        return UNRESOLVED_MSG
+        # raise e

kitt/core/schema.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel
+from typing import List, Dict, Literal, Optional
+
+class FunctionCall(BaseModel):
+    arguments: dict
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: str
+    """The name of the function to call."""
+
+class FunctionDefinition(BaseModel):
+    name: str
+    description: Optional[str] = None
+    parameters: Optional[Dict[str, object]] = None
+
+class FunctionSignature(BaseModel):
+    function: FunctionDefinition
+    type: Literal["function"]

kitt/core/utils.py

@@ -1,3 +1,5 @@
+import json
+import re
 from typing import List, Tuple, Optional, Union
 
 
@@ -33,3 +35,27 @@ def plot_route(points, vehicle: Union[tuple[float, float], None] = None):
     fig.update_geos(fitbounds="locations")
     fig.update_layout(margin={"r": 20, "t": 20, "l": 20, "b": 20})
     return fig
+
+
+def extract_json_from_markdown(text):
+    """
+    Extracts the JSON string from the given text using a regular expression pattern.
+    
+    Args:
+        text (str): The input text containing the JSON string.
+        
+    Returns:
+        dict: The JSON data loaded from the extracted string, or None if the JSON string is not found.
+    """
+    json_pattern = r'```json\r?\n(.*?)\r?\n```'
+    match = re.search(json_pattern, text, re.DOTALL)
+    if match:
+        json_string = match.group(1)
+        try:
+            data = json.loads(json_string)
+            return data
+        except json.JSONDecodeError as e:
+            print(f"Error decoding JSON string: {e}")
+    else:
+        print("JSON string not found in the text.")
+    return None

kitt/core/validator.py

@@ -0,0 +1,134 @@
+import ast
+import json
+from jsonschema import validate
+from pydantic import ValidationError
+from loguru import logger
+
+from .utils import extract_json_from_markdown
+from .schema import FunctionCall, FunctionSignature
+
+def validate_function_call_schema(call, signatures):
+    try:
+        call_data = FunctionCall(**call)
+    except ValidationError as e:
+        return False, str(e)
+
+    for signature in signatures:
+        try:
+            signature_data = FunctionSignature(**signature)
+            if signature_data.function.name == call_data.name:
+                # Validate types in function arguments
+                for arg_name, arg_schema in signature_data.function.parameters.get('properties', {}).items():
+                    if arg_name in call_data.arguments:
+                        call_arg_value = call_data.arguments[arg_name]
+                        if call_arg_value:
+                            try:
+                                validate_argument_type(arg_name, call_arg_value, arg_schema)
+                            except Exception as arg_validation_error:
+                                return False, str(arg_validation_error)
+
+                # Check if all required arguments are present
+                required_arguments = signature_data.function.parameters.get('required', [])
+                result, missing_arguments = check_required_arguments(call_data.arguments, required_arguments)
+                if not result:
+                    return False, f"Missing required arguments: {missing_arguments}"
+
+                return True, None
+        except Exception as e:
+            # Handle validation errors for the function signature
+            return False, str(e)
+
+    # No matching function signature found
+    return False, f"No matching function signature found for function: {call_data.name}"
+
+def check_required_arguments(call_arguments, required_arguments):
+    missing_arguments = [arg for arg in required_arguments if arg not in call_arguments]
+    return not bool(missing_arguments), missing_arguments
+
+def validate_enum_value(arg_name, arg_value, enum_values):
+    if arg_value not in enum_values:
+        raise Exception(
+            f"Invalid value '{arg_value}' for parameter {arg_name}. Expected one of {', '.join(map(str, enum_values))}"
+        )
+
+def validate_argument_type(arg_name, arg_value, arg_schema):
+    arg_type = arg_schema.get('type', None)
+    if arg_type:
+        if arg_type == 'string' and 'enum' in arg_schema:
+            enum_values = arg_schema['enum']
+            if None not in enum_values and enum_values != []:
+                try:
+                    validate_enum_value(arg_name, arg_value, enum_values)
+                except Exception as e:
+                    # Propagate the validation error message
+                    raise Exception(f"Error validating function call: {e}")
+
+        python_type = get_python_type(arg_type)
+        if not isinstance(arg_value, python_type):
+            raise Exception(f"Type mismatch for parameter {arg_name}. Expected: {arg_type}, Got: {type(arg_value)}")
+
+def get_python_type(json_type):
+    type_mapping = {
+        'string': str,
+        'number': (int, float),
+        'integer': int,
+        'boolean': bool,
+        'array': list,
+        'object': dict,
+        'null': type(None),
+    }
+    return type_mapping[json_type]
+
+def validate_json_data(json_object, json_schema):
+    valid = False
+    error_message = None
+    result_json = None
+
+    try:
+        # Attempt to load JSON using json.loads
+        try:
+            result_json = json.loads(json_object)
+        except json.decoder.JSONDecodeError:
+            # If json.loads fails, try ast.literal_eval
+            try:
+                result_json = ast.literal_eval(json_object)
+            except (SyntaxError, ValueError) as e:
+                try:
+                    result_json = extract_json_from_markdown(json_object)
+                except Exception as e:
+                    error_message = f"JSON decoding error: {e}"
+                    logger.info(f"Validation failed for JSON data: {error_message}")
+                    return valid, result_json, error_message
+
+        # Return early if both json.loads and ast.literal_eval fail
+        if result_json is None:
+            error_message = "Failed to decode JSON data"
+            logger.info(f"Validation failed for JSON data: {error_message}")
+            return valid, result_json, error_message
+
+        # Validate each item in the list against schema if it's a list
+        if isinstance(result_json, list):
+            for index, item in enumerate(result_json):
+                try:
+                    validate(instance=item, schema=json_schema)
+                    logger.info(f"Item {index+1} is valid against the schema.")
+                except ValidationError as e:
+                    error_message = f"Validation failed for item {index+1}: {e}"
+                    break
+        else:
+            # Default to validation without list
+            try:
+                validate(instance=result_json, schema=json_schema)
+            except ValidationError as e:
+                error_message = f"Validation failed: {e}"
+
+    except Exception as e:
+        error_message = f"Error occurred: {e}"
+
+    if error_message is None:
+        valid = True
+        logger.info("JSON data is valid against the schema.")
+    else:
+        logger.info(f"Validation failed for JSON data: {error_message}")
+
+    return valid, result_json, error_message

kitt/skills/__init__.py

@@ -1,10 +1,11 @@
 from datetime import datetime
 import inspect
+from langchain.tools import StructuredTool
 
 from .common import execute_function_call, extract_func_args, vehicle as vehicle_obj
 from .weather import get_weather_current_location, get_weather, get_forecast
 from .routing import find_route
-from .poi import search_points_of_interests, search_along_route_w_coordinates
+from .poi import search_points_of_interest, search_along_route_w_coordinates
 from .vehicle import vehicle_status, set_vehicle_speed, set_vehicle_destination
 from .interpreter import code_interpreter
 
@@ -32,6 +33,8 @@ def format_functions_for_prompt_raven(*functions):
     """
     formatted_functions = []
     for func in functions:
+        if isinstance(func, StructuredTool):
+            func = func.func
         signature = f"{func.__name__}{inspect.signature(func)}"
         docstring = inspect.getdoc(func)
         formatted_functions.append(
@@ -40,4 +43,4 @@ def format_functions_for_prompt_raven(*functions):
     return "\n".join(formatted_functions)
 
 
-SKILLS_PROMPT = format_functions_for_prompt_raven(get_weather, get_forecast, find_route, search_points_of_interests)
+SKILLS_PROMPT = format_functions_for_prompt_raven(get_weather, get_forecast, find_route, search_points_of_interest)

kitt/skills/poi.py

@@ -1,5 +1,8 @@
 import json
+import urllib.parse
 import requests
+from loguru import logger
+from langchain.tools import tool
 from .common import config, vehicle
 
 
@@ -16,7 +19,8 @@ def _select_equally_spaced_coordinates(coords, number_of_points=10):
     return selected_coords
 
 
-def search_points_of_interests(search_query="french restaurant"):
+@tool
+def search_points_of_interest(search_query: str ="french restaurant"):
     """
     Get some of the closest points of interest matching the query.
 
@@ -27,16 +31,31 @@ def search_points_of_interests(search_query="french restaurant"):
     # Extract the latitude and longitude of the vehicle
     vehicle_coordinates = getattr(vehicle, "location_coordinates")
     lat, lon = vehicle_coordinates
-    print(f"POI search vehicle's lat: {lat}, lon: {lon}")
+    logger.info(f"POI search vehicle's lat: {lat}, lon: {lon}")
 
     # https://developer.tomtom.com/search-api/documentation/search-service/search
-    r = requests.get(
-        f"https://api.tomtom.com/search/2/search/{search_query}.json?key={config.TOMTOM_API_KEY}&lat={lat}&lon={lon}&category&radius=1000&limit=100",
-        timeout=5,
-    )
+    # Encode the parameters
+    # Even with encoding tomtom doesn't return the correct results
+    search_query = search_query.replace("'", "")
+    encoded_search_query = urllib.parse.quote(search_query)
+
+    # Construct the URL
+    url = f"https://api.tomtom.com/search/2/search/{encoded_search_query}.json"
+    params = {
+        "key": config.TOMTOM_API_KEY,
+        "lat": lat,
+        "lon": lon,
+        "radius": 5000,
+        "idxSet": "POI",
+        "limit": 50
+    }
+
+    r = requests.get(url, params=params, timeout=5)
 
     # Parse JSON from the response
     data = r.json()
+
+    logger.debug(f"POI search response: {data}\n url:{url} params: {params}")
     # Extract results
     results = data["results"]
 
@@ -57,7 +76,7 @@ def search_points_of_interests(search_query="french restaurant"):
     output = (
         f"There are {len(results)} options in the vicinity. The most relevant are: "
     )
-    return output + ".\n ".join(formatted_results)
+    return output + ".\n ".join(formatted_results), results[:3]
 
 
 def find_points_of_interest(lat="0", lon="0", type_of_poi="restaurant"):
@@ -69,12 +88,14 @@ def find_points_of_interest(lat="0", lon="0", type_of_poi="restaurant"):
     :param type_of_poi (string): Required. type of point of interest depending on what the user wants to do.
     """
     # https://developer.tomtom.com/search-api/documentation/search-service/points-of-interest-search
-    r = requests.get(
-        f"https://api.tomtom.com/search/2/search/{type_of_poi}"
-        ".json?key={0}&lat={1}&lon={2}&radius=10000&vehicleTypeSet=Car&idxSet=POI&limit=100".format(
-            config.TOMTOM_API_KEY, lat, lon
-        )
-    )
+    # Encode the parameters
+    encoded_type_of_poi = urllib.parse.quote(type_of_poi)
+
+    # Construct the URL
+    url = f"https://api.tomtom.com/search/2/search/{encoded_type_of_poi}.json?key={config.TOMTOM_API_KEY}&lat={lat}&lon={lon}&radius=10000&vehicleTypeSet=Car&idxSet=POI&limit=100"
+
+    r = requests.get(url, timeout=5)
+
 
     # Parse JSON from the response
     data = r.json()
@@ -103,7 +124,11 @@ def search_along_route_w_coordinates(points: list[tuple[float, float]], query: s
     """
 
     # The API endpoint for searching along a route
-    url = f"https://api.tomtom.com/search/2/searchAlongRoute/{query}.json?key={config.TOMTOM_API_KEY}&maxDetourTime=360&limit=20&sortBy=detourTime"
+
+    # urlencode the query
+    query = urllib.parse.quote(query)
+
+    url = f"https://api.tomtom.com/search/2/searchAlongRoute/{query}.json?key={config.TOMTOM_API_KEY}&maxDetourTime=600&limit=20&sortBy=detourTime"
 
     points = _select_equally_spaced_coordinates(points, number_of_points=20)
 

kitt/skills/routing.py

@@ -1,5 +1,7 @@
 from datetime import datetime
 import requests
+from loguru import logger
+from langchain.tools import tool
 from .common import config, vehicle
 
 
@@ -120,6 +122,7 @@ def find_route_a_to_b(origin="", destination=""):
     return _format_tomtom_trip_info(trip_info, destination)
 
 
+@tool
 def find_route(destination):
     """Get a route to a destination from the current location of the vehicle.
 

kitt/skills/vehicle.py

@@ -1,3 +1,5 @@
+from langchain.tools import tool
+
 from .common import vehicle, Speed
 
 
@@ -35,8 +37,8 @@ def vehicle_status() -> tuple[str, dict[str, str]]:
     return  STATUS_TEMPLATE.format(**vs), vs
 
 
-
-def set_vehicle_speed(speed: Speed):
+@tool
+def set_vehicle_speed(speed: Speed) -> str:
     """Set the speed of the vehicle.
     Args:
         speed (Speed): The speed of the vehicle. ("slow", "fast")
@@ -44,7 +46,8 @@ def set_vehicle_speed(speed: Speed):
     vehicle.speed = speed
     return f"The vehicle speed is set to {speed.value}."
 
-def set_vehicle_destination(destination: str):
+@tool
+def set_vehicle_destination(destination: str) -> str:
     """Set the destination of the vehicle.
     Args:
         destination (str): The destination of the vehicle.

kitt/skills/weather.py

@@ -1,5 +1,6 @@
 import requests
 from loguru import logger
+from langchain.tools import tool
 
 from .common import config, vehicle
 
@@ -19,7 +20,7 @@ def get_weather_current_location():
     return get_weather(location)
 
 
-# current weather API
+@tool
 def get_weather(location: str = "here"):
     """
     Get the current weather in a specified location.
@@ -70,7 +71,8 @@ def get_weather(location: str = "here"):
         # f"Humidity is at {humidity}%. "
         # f"Wind speed is {wind_kph} kph." if 'wind_kph' in weather_data['current'] else ""
     )
-    return weather_sentences, weather_data
+    # return weather_sentences, weather_data
+    return weather_sentences
 
 
 # weather forecast API

main.py

@@ -12,7 +12,8 @@ import ollama
 
 from langchain.tools.base import StructuredTool
 from langchain.memory import ChatMessageHistory
-from langchain_core.utils.function_calling import convert_to_openai_function
+from langchain_core.utils.function_calling import convert_to_openai_tool
+from langchain.tools import tool
 from loguru import logger
 
 
@@ -22,7 +23,7 @@ from kitt.skills import (
     get_forecast,
     vehicle_status as vehicle_status_fn,
     set_vehicle_speed,
-    search_points_of_interests,
+    search_points_of_interest,
     search_along_route_w_coordinates,
     set_vehicle_destination,
     do_anything_else,
@@ -32,7 +33,8 @@ from kitt.skills import (
 )
 from kitt.skills import extract_func_args
 from kitt.core import voice_options, tts_gradio
-from kitt.core.model import process_query
+# from kitt.core.model import process_query
+from kitt.core.model import generate_function_call as process_query
 from kitt.core import utils as kitt_utils
 
 
@@ -68,6 +70,8 @@ Answer questions concisely and do not mention what you base your reply on.<|im_e
 <|im_start|>assistant
 """
 
+USER_PREFERENCES = "I love italian food\nI like doing sports"
+
 
 def get_prompt(template, input, history, tools):
     # "vehicle_status": vehicle_status_fn()[0]
@@ -98,6 +102,7 @@ def use_tool(func_name, kwargs, tools):
 hour_options = [f"{i:02d}:00:00" for i in range(24)]
 
 
+@tool
 def search_along_route(query=""):
     """Search for points of interest along the route/way to the destination.
 
@@ -120,18 +125,29 @@ def get_vehicle_status(state):
 
 
 tools = [
-    StructuredTool.from_function(get_weather),
-    StructuredTool.from_function(find_route),
+    # StructuredTool.from_function(get_weather),
+    # StructuredTool.from_function(find_route),
     # StructuredTool.from_function(vehicle_status_fn),
-    StructuredTool.from_function(set_vehicle_speed),
-    StructuredTool.from_function(search_points_of_interests),
-    StructuredTool.from_function(search_along_route),
+    # StructuredTool.from_function(set_vehicle_speed),
+    # StructuredTool.from_function(set_vehicle_destination),
+    # StructuredTool.from_function(search_points_of_interest),
+    # StructuredTool.from_function(search_along_route),
     # StructuredTool.from_function(date_time_info),
     # StructuredTool.from_function(get_weather_current_location),
-    StructuredTool.from_function(code_interpreter),
+    # StructuredTool.from_function(code_interpreter),
     # StructuredTool.from_function(do_anything_else),
 ]
 
+functions = [
+    set_vehicle_speed,
+    set_vehicle_destination,
+    get_weather,
+    find_route,
+    search_points_of_interest,
+    search_along_route
+]
+openai_tools = [convert_to_openai_tool(tool) for tool in functions]
+
 
 def run_generic_model(query):
     print(f"Running the generic model with query: {query}")
@@ -186,11 +202,16 @@ def run_nexusraven_model(query, voice_character, state):
 
 
 def run_llama3_model(query, voice_character, state):
+
+    assert len (functions) > 0, "No functions to call"
+    assert len (openai_tools) > 0, "No openai tools to call"
+
     output_text = process_query(
         query,
         history=history,
         user_preferences=state["user_preferences"],
-        tools=tools,
+        tools=openai_tools,
+        functions=functions,
         backend=state["llm_backend"],
     )
     gr.Info(f"Output text: {output_text}, generating voice output...")
@@ -216,6 +237,9 @@ def run_model(query, voice_character, state):
         text, voice = run_llama3_model(query, voice_character, state)
     else:
         text, voice = "Error running model", None
+
+    if not state["enable_history"]:
+        history.clear()
     return text, voice, vehicle.model_dump_json()
 
 
@@ -285,8 +309,8 @@ def save_and_transcribe_audio(audio):
 
 def save_and_transcribe_run_model(audio, voice_character, state):
     text = save_and_transcribe_audio(audio)
-    out_text, out_voice = run_model(text, voice_character, state)
-    return text, out_text, out_voice
+    out_text, out_voice, vehicle_status = run_model(text, voice_character, state)
+    return text, out_text, out_voice, vehicle_status
 
 
 def set_tts_enabled(tts_enabled, state):
@@ -314,6 +338,12 @@ def set_user_preferences(preferences, state):
     return state
 
 
+def set_enable_history(enable_history, state):
+    new_enable_history = enable_history == "Yes"
+    logger.info(f"Enable history was {state['enable_history']} and changed to {new_enable_history}")
+    state["enable_history"] = new_enable_history
+    return state
+
 # to be able to use the microphone on chrome, you will have to go to chrome://flags/#unsafely-treat-insecure-origin-as-secure and enter http://10.186.115.21:7860/
 # in "Insecure origins treated as secure", enable it and relaunch chrome
 
@@ -322,6 +352,10 @@ def set_user_preferences(preferences, state):
 # What's the closest restaurant from here?
 
 
+ORIGIN = "Mondorf-les-Bains, Luxembourg"
+DESTINATION = "Rue Alphonse Weicker, Luxembourg"
+
+
 def create_demo(tts_server: bool = False, model="llama3", tts_enabled: bool = True):
     print(f"Running the demo with model: {model} and TTSServer: {tts_server}")
     with gr.Blocks(theme=gr.themes.Default()) as demo:
@@ -332,11 +366,13 @@ def create_demo(tts_server: bool = False, model="llama3", tts_enabled: bool = Tr
                 "route_points": [],
                 "model": model,
                 "tts_enabled": tts_enabled,
-                "llm_backend": "Ollama",
-                "user_preferences": "",
+                "llm_backend": "ollama",
+                "user_preferences": USER_PREFERENCES,
+                "enable_history": False,
             }
         )
         trip_points = gr.State(value=[])
+        plot, vehicle_status, _ = calculate_route_gradio(ORIGIN, DESTINATION)
 
         with gr.Row():
             with gr.Column(scale=1, min_width=300):
@@ -346,12 +382,6 @@ def create_demo(tts_server: bool = False, model="llama3", tts_enabled: bool = Tr
                     value="08:00:00",
                     interactive=True,
                 )
-                history = gr.Radio(
-                    ["Yes", "No"],
-                    label="Maintain the conversation history?",
-                    value="No",
-                    interactive=True,
-                )
                 voice_character = gr.Radio(
                     choices=voice_options,
                     label="Choose a voice",
@@ -359,24 +389,24 @@ def create_demo(tts_server: bool = False, model="llama3", tts_enabled: bool = Tr
                     show_label=True,
                 )
                 origin = gr.Textbox(
-                    value="Mondorf-les-Bains, Luxembourg",
+                    value=ORIGIN,
                     label="Origin",
                     interactive=True,
                 )
                 destination = gr.Textbox(
-                    value="Rue Alphonse Weicker, Luxembourg",
+                    value=DESTINATION,
                     label="Destination",
                     interactive=True,
                 )
                 preferences = gr.Textbox(
-                    value="I love italian food\nI like doing sports",
+                    value=USER_PREFERENCES,
                     label="User preferences",
                     lines=3,
                     interactive=True,
                 )
 
             with gr.Column(scale=2, min_width=600):
-                map_plot = gr.Plot()
+                map_plot = gr.Plot(value=plot, label="Map")
                 trip_progress = gr.Slider(
                     0, 100, step=5, label="Trip progress", interactive=True
                 )
@@ -422,6 +452,12 @@ def create_demo(tts_server: bool = False, model="llama3", tts_enabled: bool = Tr
                         value="Ollama",
                         interactive=True,
                     )
+                    enable_history = gr.Radio(
+                        ["Yes", "No"],
+                        label="Maintain the conversation history?",
+                        value="No",
+                        interactive=True,
+                    )
                 # Push button
                 clear_history_btn = gr.Button(value="Clear History")
             with gr.Column():
@@ -472,7 +508,7 @@ def create_demo(tts_server: bool = False, model="llama3", tts_enabled: bool = Tr
         input_audio.stop_recording(
             fn=save_and_transcribe_run_model,
             inputs=[input_audio, voice_character, state],
-            outputs=[input_text, output_text, output_audio],
+            outputs=[input_text, output_text, output_audio, vehicle_status],
         )
         input_audio_debug.stop_recording(
             fn=save_and_transcribe_audio,
@@ -490,6 +526,10 @@ def create_demo(tts_server: bool = False, model="llama3", tts_enabled: bool = Tr
         llm_backend.change(
             fn=set_llm_backend, inputs=[llm_backend, state], outputs=[state]
         )
+        enable_history.change(
+            fn=set_enable_history, inputs=[enable_history, state], outputs=[state]
+        )
+        
     return demo