增加auto-gpt0.5版本

autogpt/json_utils/json_fix_general.py

@@ -0,0 +1,124 @@
+"""This module contains functions to fix JSON strings using general programmatic approaches, suitable for addressing
+common JSON formatting issues."""
+from __future__ import annotations
+
+import contextlib
+import json
+import re
+from typing import Optional
+
+from autogpt.config import Config
+from autogpt.json_utils.utilities import extract_char_position
+
+CFG = Config()
+
+
+def fix_invalid_escape(json_to_load: str, error_message: str) -> str:
+    """Fix invalid escape sequences in JSON strings.
+
+    Args:
+        json_to_load (str): The JSON string.
+        error_message (str): The error message from the JSONDecodeError
+          exception.
+
+    Returns:
+        str: The JSON string with invalid escape sequences fixed.
+    """
+    while error_message.startswith("Invalid \\escape"):
+        bad_escape_location = extract_char_position(error_message)
+        json_to_load = (
+            json_to_load[:bad_escape_location] + json_to_load[bad_escape_location + 1 :]
+        )
+        try:
+            json.loads(json_to_load)
+            return json_to_load
+        except json.JSONDecodeError as e:
+            if CFG.debug_mode:
+                print("json loads error - fix invalid escape", e)
+            error_message = str(e)
+    return json_to_load
+
+
+def balance_braces(json_string: str) -> Optional[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
+
+    with contextlib.suppress(json.JSONDecodeError):
+        json.loads(json_string)
+        return json_string
+
+
+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: re.Match) -> str:
+        return f'"{match[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 correct_json(json_to_load: str) -> str:
+    """
+    Correct common JSON errors.
+    Args:
+        json_to_load (str): The JSON string.
+    """
+
+    try:
+        if CFG.debug_mode:
+            print("json", json_to_load)
+        json.loads(json_to_load)
+        return json_to_load
+    except json.JSONDecodeError as e:
+        if CFG.debug_mode:
+            print("json loads error", e)
+        error_message = str(e)
+        if error_message.startswith("Invalid \\escape"):
+            json_to_load = fix_invalid_escape(json_to_load, error_message)
+        if error_message.startswith(
+            "Expecting property name enclosed in double quotes"
+        ):
+            json_to_load = add_quotes_to_property_names(json_to_load)
+            try:
+                json.loads(json_to_load)
+                return json_to_load
+            except json.JSONDecodeError as e:
+                if CFG.debug_mode:
+                    print("json loads error - add quotes", e)
+                error_message = str(e)
+        if balanced_str := balance_braces(json_to_load):
+            return balanced_str
+    return json_to_load

autogpt/json_utils/json_fix_llm.py

@@ -0,0 +1,220 @@
+"""This module contains functions to fix JSON strings generated by LLM models, such as ChatGPT, using the assistance
+of the ChatGPT API or LLM models."""
+from __future__ import annotations
+
+import contextlib
+import json
+from typing import Any, Dict
+
+from colorama import Fore
+from regex import regex
+
+from autogpt.config import Config
+from autogpt.json_utils.json_fix_general import correct_json
+from autogpt.llm_utils import call_ai_function
+from autogpt.logs import logger
+from autogpt.speech import say_text
+
+JSON_SCHEMA = """
+{
+    "command": {
+        "name": "command name",
+        "args": {
+            "arg name": "value"
+        }
+    },
+    "thoughts":
+    {
+        "text": "thought",
+        "reasoning": "reasoning",
+        "plan": "- short bulleted\n- list that conveys\n- long-term plan",
+        "criticism": "constructive self-criticism",
+        "speak": "thoughts summary to say to user"
+    }
+}
+"""
+
+CFG = Config()
+
+
+def auto_fix_json(json_string: str, schema: str) -> str:
+    """Fix the given JSON string to make it parseable and fully compliant with
+        the provided schema using GPT-3.
+
+    Args:
+        json_string (str): The JSON string to fix.
+        schema (str): The schema to use to fix the JSON.
+    Returns:
+        str: The fixed JSON string.
+    """
+    # Try to fix the JSON using GPT:
+    function_string = "def fix_json(json_string: str, schema:str=None) -> str:"
+    args = [f"'''{json_string}'''", f"'''{schema}'''"]
+    description_string = (
+        "This function takes a JSON string and ensures that it"
+        " is parseable and fully compliant with the provided schema. If an object"
+        " or field specified in the schema isn't contained within the correct JSON,"
+        " it is omitted. The function also escapes any double quotes within JSON"
+        " string values to ensure that they are valid. If the JSON string contains"
+        " any None or NaN values, they are replaced with null before being parsed."
+    )
+
+    # If it doesn't already start with a "`", add one:
+    if not json_string.startswith("`"):
+        json_string = "```json\n" + json_string + "\n```"
+    result_string = call_ai_function(
+        function_string, args, description_string, model=CFG.fast_llm_model
+    )
+    logger.debug("------------ JSON FIX ATTEMPT ---------------")
+    logger.debug(f"Original JSON: {json_string}")
+    logger.debug("-----------")
+    logger.debug(f"Fixed JSON: {result_string}")
+    logger.debug("----------- END OF FIX ATTEMPT ----------------")
+
+    try:
+        json.loads(result_string)  # just check the validity
+        return result_string
+    except json.JSONDecodeError:  # noqa: E722
+        # Get the call stack:
+        # import traceback
+        # call_stack = traceback.format_exc()
+        # print(f"Failed to fix JSON: '{json_string}' "+call_stack)
+        return "failed"
+
+
+def fix_json_using_multiple_techniques(assistant_reply: str) -> Dict[Any, Any]:
+    """Fix the given JSON string to make it parseable and fully compliant with two techniques.
+
+    Args:
+        json_string (str): The JSON string to fix.
+
+    Returns:
+        str: The fixed JSON string.
+    """
+
+    # Parse and print Assistant response
+    assistant_reply_json = fix_and_parse_json(assistant_reply)
+    if assistant_reply_json == {}:
+        assistant_reply_json = attempt_to_fix_json_by_finding_outermost_brackets(
+            assistant_reply
+        )
+
+    if assistant_reply_json != {}:
+        return assistant_reply_json
+
+    logger.error(
+        "Error: The following AI output couldn't be converted to a JSON:\n",
+        assistant_reply,
+    )
+    if CFG.speak_mode:
+        say_text("I have received an invalid JSON response from the OpenAI API.")
+
+    return {}
+
+
+def fix_and_parse_json(
+    json_to_load: str, try_to_fix_with_gpt: bool = True
+) -> Dict[Any, Any]:
+    """Fix and parse JSON string
+
+    Args:
+        json_to_load (str): The JSON string.
+        try_to_fix_with_gpt (bool, optional): Try to fix the JSON with GPT.
+            Defaults to True.
+
+    Returns:
+        str or dict[Any, Any]: The parsed JSON.
+    """
+
+    with contextlib.suppress(json.JSONDecodeError):
+        json_to_load = json_to_load.replace("\t", "")
+        return json.loads(json_to_load)
+
+    with contextlib.suppress(json.JSONDecodeError):
+        json_to_load = correct_json(json_to_load)
+        return json.loads(json_to_load)
+    # 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_to_load.index("{")
+        maybe_fixed_json = json_to_load[brace_index:]
+        last_brace_index = maybe_fixed_json.rindex("}")
+        maybe_fixed_json = maybe_fixed_json[: last_brace_index + 1]
+        return json.loads(maybe_fixed_json)
+    except (json.JSONDecodeError, ValueError) as e:
+        return try_ai_fix(try_to_fix_with_gpt, e, json_to_load)
+
+
+def try_ai_fix(
+    try_to_fix_with_gpt: bool, exception: Exception, json_to_load: str
+) -> Dict[Any, Any]:
+    """Try to fix the JSON with the AI
+
+    Args:
+        try_to_fix_with_gpt (bool): Whether to try to fix the JSON with the AI.
+        exception (Exception): The exception that was raised.
+        json_to_load (str): The JSON string to load.
+
+    Raises:
+        exception: If try_to_fix_with_gpt is False.
+
+    Returns:
+        str or dict[Any, Any]: The JSON string or dictionary.
+    """
+    if not try_to_fix_with_gpt:
+        raise exception
+    if CFG.debug_mode:
+        logger.warn(
+            "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 = auto_fix_json(json_to_load, JSON_SCHEMA)
+
+    if ai_fixed_json != "failed":
+        return json.loads(ai_fixed_json)
+    # This allows the AI to react to the error message,
+    #   which usually results in it correcting its ways.
+    # logger.error("Failed to fix AI output, telling the AI.")
+    return {}
+
+
+def attempt_to_fix_json_by_finding_outermost_brackets(json_string: str):
+    if CFG.speak_mode and CFG.debug_mode:
+        say_text(
+            "I have received an invalid JSON response from the OpenAI API. "
+            "Trying to fix it now."
+        )
+        logger.error("Attempting to fix JSON by finding outermost brackets\n")
+
+    try:
+        json_pattern = regex.compile(r"\{(?:[^{}]|(?R))*\}")
+        json_match = json_pattern.search(json_string)
+
+        if json_match:
+            # Extract the valid JSON object from the string
+            json_string = json_match.group(0)
+            logger.typewriter_log(
+                title="Apparently json was fixed.", title_color=Fore.GREEN
+            )
+            if CFG.speak_mode and CFG.debug_mode:
+                say_text("Apparently json was fixed.")
+        else:
+            return {}
+
+    except (json.JSONDecodeError, ValueError):
+        if CFG.debug_mode:
+            logger.error(f"Error: Invalid JSON: {json_string}\n")
+        if CFG.speak_mode:
+            say_text("Didn't work. I will have to ignore this response then.")
+        logger.error("Error: Invalid JSON, setting it to empty JSON now.\n")
+        json_string = {}
+
+    return fix_and_parse_json(json_string)

autogpt/json_utils/llm_response_format_1.json

@@ -0,0 +1,31 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "thoughts": {
+            "type": "object",
+            "properties": {
+                "text": {"type": "string"},
+                "reasoning": {"type": "string"},
+                "plan": {"type": "string"},
+                "criticism": {"type": "string"},
+                "speak": {"type": "string"}
+            },
+            "required": ["text", "reasoning", "plan", "criticism", "speak"],
+            "additionalProperties": false
+        },
+        "command": {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"},
+                "args": {
+                    "type": "object"
+                }
+            },
+            "required": ["name", "args"],
+            "additionalProperties": false
+        }
+    },
+    "required": ["thoughts", "command"],
+    "additionalProperties": false
+}

autogpt/json_utils/utilities.py

@@ -0,0 +1,54 @@
+"""Utilities for the json_fixes package."""
+import json
+import re
+
+from jsonschema import Draft7Validator
+
+from autogpt.config import Config
+from autogpt.logs import logger
+
+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.
+    """
+
+    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 validate_json(json_object: object, schema_name: object) -> object:
+    """
+    :type schema_name: object
+    :param schema_name:
+    :type json_object: object
+    """
+    with open(f"/Users/kilig/Job/Python-project/academic_gpt/autogpt/json_utils/{schema_name}.json", "r") as f:
+        schema = json.load(f)
+    validator = Draft7Validator(schema)
+
+    if errors := sorted(validator.iter_errors(json_object), key=lambda e: e.path):
+        logger.error("The JSON object is invalid.")
+        if CFG.debug_mode:
+            logger.error(
+                json.dumps(json_object, indent=4)
+            )  # Replace 'json_object' with the variable containing the JSON data
+            logger.error("The following issues were found:")
+
+            for error in errors:
+                logger.error(f"Error: {error.message}")
+    elif CFG.debug_mode:
+        print("The JSON object is valid.")
+
+    return json_object