Merge branch 'master' into dev

scripts/browse.py

@@ -7,7 +7,14 @@ cfg = Config()
 
 def scrape_text(url):
     """Scrape text from a webpage"""
-    response = requests.get(url, headers=cfg.user_agent_header)
+    # Most basic check if the URL is valid:
+    if not url.startswith('http'):
+        return "Error: Invalid URL"
+    
+    try:
+        response = requests.get(url, headers=cfg.user_agent_header)
+    except requests.exceptions.RequestException as e:
+        return "Error: " + str(e)
 
     # Check if the response contains an HTTP error
     if response.status_code >= 400:

scripts/call_ai_function.py

@@ -5,8 +5,10 @@ cfg = Config()
 from llm_utils import create_chat_completion
 # This is a magic function that can do anything with no-code. See
 # https://github.com/Torantulino/AI-Functions for more info.
-def call_ai_function(function, args, description, model=cfg.smart_llm_model):
-    """Call an AI function with the given args and description."""
+def call_ai_function(function, args, description, model=None):
+    """Call an AI function"""
+    if model is None:
+        model = cfg.smart_llm_model
     # For each arg, if any are None, convert to "None":
     args = [str(arg) if arg is not None else "None" for arg in args]
     # parse args to comma seperated string

scripts/commands.py

@@ -108,6 +108,8 @@ def execute_command(command_name, arguments):
             return execute_python_file(arguments["file"])
         elif command_name == "generate_image":
             return generate_image(arguments["prompt"])
+        elif command_name == "do_nothing":
+            return "No action performed."
         elif command_name == "task_complete":
             shutdown()
         else:
@@ -299,4 +301,4 @@ def delete_agent(key):
     result = agents.delete_agent(key)
     if not result:
         return f"Agent {key} does not exist."
-    return f"Agent {key} deleted."
+    return f"Agent {key} deleted."

scripts/data/prompt.txt

@@ -24,6 +24,7 @@ COMMANDS:
 18. Execute Python File: "execute_python_file", args: "file": "<file>"
 19. Task Complete (Shutdown): "task_complete", args: "reason": "<reason>"
 20. Generate Image: "generate_image", args: "prompt": "<prompt>"
+21. Do Nothing; command name: "do_nothing", args: ""
 
 RESOURCES:
 

scripts/json_parser.py

@@ -1,12 +1,13 @@
 import json
+from typing import Any, Dict, Union
 from call_ai_function import call_ai_function
 from config import Config
+from json_utils import correct_json
+
 cfg = Config()
 
-def fix_and_parse_json(json_str: str, try_to_fix_with_gpt: bool = True):
-    """Fix and parse the given JSON string."""
-    json_schema = """
-    {
+JSON_SCHEMA = """
+{
     "command": {
         "name": "command name",
         "args":{
@@ -21,45 +22,70 @@ def fix_and_parse_json(json_str: str, try_to_fix_with_gpt: bool = True):
         "criticism": "constructive self-criticism",
         "speak": "thoughts summary to say to user"
     }
-    }
-    """
+}
+"""
 
+
+def fix_and_parse_json(    
+    json_str: str,
+    try_to_fix_with_gpt: bool = True
+) -> Union[str, Dict[Any, Any]]:
+    """Fix and parse JSON string"""
     try:
         json_str = json_str.replace('\t', '')
         return json.loads(json_str)
-    except Exception as e:
-        # Let's do something manually - sometimes GPT responds with something BEFORE the braces:
-        # "I'm sorry, I don't understand. Please try again."{"text": "I'm sorry, I don't understand. Please try again.", "confidence": 0.0}
-        # So let's try to find the first brace and then parse the rest of the string
+    except json.JSONDecodeError as _:  # noqa: F841
+        json_str = correct_json(json_str)
         try:
-          brace_index = json_str.index("{")
-          json_str = json_str[brace_index:]
-          last_brace_index = json_str.rindex("}")
-          json_str = json_str[:last_brace_index+1]
-          return json.loads(json_str)
-        except Exception as e:
-          if try_to_fix_with_gpt:
-            print(f"Warning: Failed to parse AI output, attempting to fix.\n If you see this warning frequently, it's likely that your prompt is confusing the AI. Try changing it up slightly.")
+            return json.loads(json_str)
+        except json.JSONDecodeError as _:  # noqa: F841
+            pass
+    # Let's do something manually:
+    # sometimes GPT responds with something BEFORE the braces:
+    # "I'm sorry, I don't understand. Please try again."
+    # {"text": "I'm sorry, I don't understand. Please try again.",
+    #  "confidence": 0.0}
+    # So let's try to find the first brace and then parse the rest
+    #  of the string
+    try:
+        brace_index = json_str.index("{")
+        json_str = json_str[brace_index:]
+        last_brace_index = json_str.rindex("}")
+        json_str = json_str[:last_brace_index+1]
+        return json.loads(json_str)
+    except json.JSONDecodeError as e:  # noqa: F841
+        if try_to_fix_with_gpt:
+            print("Warning: Failed to parse AI output, attempting to fix."
+                  "\n If you see this warning frequently, it's likely that"
+                  " your prompt is confusing the AI. Try changing it up"
+                  " slightly.")
             # Now try to fix this up using the ai_functions
-            ai_fixed_json = fix_json(json_str, json_schema, cfg.debug)
+            ai_fixed_json = fix_json(json_str, JSON_SCHEMA, cfg.debug)
             if ai_fixed_json != "failed":
-              return json.loads(ai_fixed_json)
+                return json.loads(ai_fixed_json)
             else:
-              print(f"Failed to fix ai output, telling the AI.") # This allows the AI to react to the error message, which usually results in it correcting its ways.
-              return json_str
-          else:
+                # This allows the AI to react to the error message,
+                #   which usually results in it correcting its ways.
+                print("Failed to fix ai output, telling the AI.")
+                return json_str
+        else:
             raise e
-        
+
+
 def fix_json(json_str: str, schema: str, debug=False) -> str:
     """Fix the given JSON string to make it parseable and fully complient with the provided schema."""
     # Try to fix the JSON using gpt:
     function_string = "def fix_json(json_str: str, schema:str=None) -> str:"
     args = [f"'''{json_str}'''", f"'''{schema}'''"]
-    description_string = """Fixes the provided JSON string to make it parseable and fully complient with the provided schema.\n If an object or field specifed in the schema isn't contained within the correct JSON, it is ommited.\n This function is brilliant at guessing when the format is incorrect."""
+    description_string = "Fixes the provided JSON string to make it parseable"\
+        " and fully complient with the provided schema.\n If an object or"\
+        " field specifed in the schema isn't contained within the correct"\
+        " JSON, it is ommited.\n This function is brilliant at guessing"\
+        " when the format is incorrect."
 
     # If it doesn't already start with a "`", add one:
     if not json_str.startswith("`"):
-      json_str = "```json\n" + json_str + "\n```"
+        json_str = "```json\n" + json_str + "\n```"
     result_string = call_ai_function(
         function_string, args, description_string, model=cfg.fast_llm_model
     )
@@ -71,11 +97,11 @@ def fix_json(json_str: str, schema: str, debug=False) -> str:
         print("----------- END OF FIX ATTEMPT ----------------")
 
     try:
-        json.loads(result_string) # just check the validity
+        json.loads(result_string)  # just check the validity
         return result_string
-    except:
+    except:  # noqa: E722
         # Get the call stack:
         # import traceback
         # call_stack = traceback.format_exc()
         # print(f"Failed to fix JSON: '{json_str}' "+call_stack)
-        return "failed"
+        return "failed"

scripts/json_utils.py

@@ -0,0 +1,127 @@
+import re
+import json
+from config import Config
+
+cfg = Config()
+
+
+def extract_char_position(error_message: str) -> int:
+    """Extract the character position from the JSONDecodeError message.
+
+    Args:
+        error_message (str): The error message from the JSONDecodeError
+          exception.
+
+    Returns:
+        int: The character position.
+    """
+    import re
+
+    char_pattern = re.compile(r'\(char (\d+)\)')
+    if match := char_pattern.search(error_message):
+        return int(match[1])
+    else:
+        raise ValueError("Character position not found in the error message.")
+
+
+def add_quotes_to_property_names(json_string: str) -> str:
+    """
+    Add quotes to property names in a JSON string.
+
+    Args:
+        json_string (str): The JSON string.
+
+    Returns:
+        str: The JSON string with quotes added to property names.
+    """
+
+    def replace_func(match):
+        return f'"{match.group(1)}":'
+
+    property_name_pattern = re.compile(r'(\w+):')
+    corrected_json_string = property_name_pattern.sub(
+        replace_func,
+        json_string)
+
+    try:
+        json.loads(corrected_json_string)
+        return corrected_json_string
+    except json.JSONDecodeError as e:
+        raise e
+
+
+def balance_braces(json_string: str) -> str:
+    """
+    Balance the braces in a JSON string.
+
+    Args:
+        json_string (str): The JSON string.
+
+    Returns:
+        str: The JSON string with braces balanced.
+    """
+
+    open_braces_count = json_string.count('{')
+    close_braces_count = json_string.count('}')
+
+    while open_braces_count > close_braces_count:
+        json_string += '}'
+        close_braces_count += 1
+
+    while close_braces_count > open_braces_count:
+        json_string = json_string.rstrip('}')
+        close_braces_count -= 1
+
+    try:
+        json.loads(json_string)
+        return json_string
+    except json.JSONDecodeError as e:
+        raise e
+
+
+def fix_invalid_escape(json_str: str, error_message: str) -> str:
+    while error_message.startswith('Invalid \\escape'):
+        bad_escape_location = extract_char_position(error_message)
+        json_str = json_str[:bad_escape_location] + \
+            json_str[bad_escape_location + 1:]
+        try:
+            json.loads(json_str)
+            return json_str
+        except json.JSONDecodeError as e:
+            if cfg.debug:
+                print('json loads error - fix invalid escape', e)
+            error_message = str(e)
+    return json_str
+
+
+def correct_json(json_str: str) -> str:
+    """
+    Correct common JSON errors.
+
+    Args:
+        json_str (str): The JSON string.
+    """
+
+    try:
+        if cfg.debug:
+            print("json", json_str)
+        json.loads(json_str)
+        return json_str
+    except json.JSONDecodeError as e:
+        if cfg.debug:
+            print('json loads error', e)
+        error_message = str(e)
+        if error_message.startswith('Invalid \\escape'):
+            json_str = fix_invalid_escape(json_str, error_message)
+        if error_message.startswith('Expecting property name enclosed in double quotes'):
+            json_str = add_quotes_to_property_names(json_str)
+            try:
+                json.loads(json_str)
+                return json_str
+            except json.JSONDecodeError as e:
+                if cfg.debug:
+                    print('json loads error - add quotes', e)
+                error_message = str(e)
+        if balanced_str := balance_braces(json_str):
+            return balanced_str
+    return json_str