Remove unused files

.gitignore

@@ -7,3 +7,4 @@ __pycache__/
 inference_logs/
 
 logs/*
+*.log

src/functioncall.py

@@ -1,141 +0,0 @@
-import argparse
-import torch
-import json
-from config import config
-from typing import List, Dict
-from logger import logger
-
-from transformers import AutoTokenizer
-
-import functions
-from prompter import PromptManager
-from validator import validate_function_call_schema
-from langchain_community.chat_models import ChatOllama
-from langchain_community.llms import Ollama
-from langchain.prompts import PromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-
-from utils import (
-    get_chat_template,
-    validate_and_extract_tool_calls
-)
-
-class ModelInference:
-    def __init__(self, chat_template: str):
-        self.prompter = PromptManager()
-        
-        self.model = Ollama(model=config.ollama_model, temperature=0.0, format='json')
-        template = PromptTemplate(template="""<|im_start|>system\nYou are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "get_stock_fundamentals", "description": "get_stock_fundamentals(symbol: str) -> dict - Get fundamental data for a given stock symbol using yfinance API.\\n\\n    Args:\\n        symbol (str): The stock symbol.\\n\\n    Returns:\\n        dict: A dictionary containing fundamental data.\\n            Keys:\\n                - \'symbol\': The stock symbol.\\n                - \'company_name\': The long name of the company.\\n                - \'sector\': The sector to which the company belongs.\\n                - \'industry\': The industry to which the company belongs.\\n                - \'market_cap\': The market capitalization of the company.\\n                - \'pe_ratio\': The forward price-to-earnings ratio.\\n                - \'pb_ratio\': The price-to-book ratio.\\n                - \'dividend_yield\': The dividend yield.\\n                - \'eps\': The trailing earnings per share.\\n                - \'beta\': The beta value of the stock.\\n                - \'52_week_high\': The 52-week high price of the stock.\\n                - \'52_week_low\': The 52-week low price of the stock.", "parameters": {"type": "object", "properties": {"symbol": {"type": "string"}}, "required": ["symbol"]}}}  </tools> Use the following pydantic model json schema for each tool call you will make: {"properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"], "title": "FunctionCall", "type": "object"} For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:\n<tool_call>\n{"arguments": <args-dict>, "name": <function-name>}\n</tool_call><|im_end|>\n""", input_variables=["question"])
-        chain = template | self.model | StrOutputParser()
-        
-        self.tokenizer = AutoTokenizer.from_pretrained(config.hf_model, trust_remote_code=True)
-        self.tokenizer.pad_token = self.tokenizer.eos_token
-        self.tokenizer.padding_side = "left"
-
-        if self.tokenizer.chat_template is None:
-            print("No chat template defined, getting chat_template...")
-            self.tokenizer.chat_template = get_chat_template(chat_template)
-
-        logger.info(f"Model loaded: {self.model}")
-
-    def process_completion_and_validate(self, completion, chat_template):
-        if completion:
-            # completion = f"<tool_call>\n{completion}\n</tool_call>"]
-            validation, tool_calls, error_message = validate_and_extract_tool_calls(completion)
-
-            if validation:
-                logger.info(f"parsed tool calls:\n{json.dumps(tool_calls, indent=2)}")
-                return tool_calls, completion, error_message
-            else:
-                tool_calls = None
-                return tool_calls, completion, error_message
-        else:
-            logger.warning("Assistant message is None")
-            raise ValueError("Assistant message is None")
-        
-    def execute_function_call(self, tool_call):
-        # config.status.update(label=":mag: Gathering information..")
-        function_name = tool_call.get("name")
-        function_to_call = getattr(functions, function_name, None)
-        function_args = tool_call.get("arguments", {})
-
-        logger.info(f"Invoking function call {function_name} ...")
-        function_response = function_to_call(*function_args.values())
-        results_dict = f'{{"name": "{function_name}", "content": {function_response}}}'
-        return results_dict
-    
-    def run_inference(self, prompt: List[Dict[str, str]]):
-        inputs = self.tokenizer.apply_chat_template(
-            prompt,
-            add_generation_prompt=True,
-            tokenize=False,
-        )
-        inputs = inputs.replace("<|begin_of_text|>", "") # Something wrong with the chat template, hotfix
-        completion = self.model.invoke(inputs, format='json')
-        return completion.content
-
-    def generate_function_call(self, query, chat_template, num_fewshot, max_depth=5):
-        try:
-            depth = 0
-            user_message = f"{query}\nThis is the first turn and you don't have <tool_results> to analyze yet"
-            chat = [{"role": "user", "content": user_message}]
-            tools = functions.get_openai_tools()
-            prompt = self.prompter.generate_prompt(chat, tools, num_fewshot)
-            # config.status.update(label=":brain: Thinking..")
-            completion = self.run_inference(prompt)
-
-            def recursive_loop(prompt, completion, depth):
-                nonlocal max_depth
-                tool_calls, assistant_message, error_message = self.process_completion_and_validate(completion, chat_template)
-                prompt.append({"role": "assistant", "content": assistant_message})
-
-                tool_message = f"Agent iteration {depth} to assist with user query: {query}\n"
-                logger.info(f"Found tool calls: {tool_calls}")
-                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 = self.execute_function_call(tool_call)
-                                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.info(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.info(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})
-
-                    depth += 1
-                    if depth >= max_depth:
-                        print(f"Maximum recursion depth reached ({max_depth}). Stopping recursion.")
-                        completion = self.run_inference(prompt)
-                        return completion
-
-                    # config.status.update(label=":brain: Analysing information..")
-                    completion = self.run_inference(prompt)
-                    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:
-                        print(f"Maximum recursion depth reached ({max_depth}). Stopping recursion.")
-                        return completion
-
-                    completion = self.run_inference(prompt)
-                    return recursive_loop(prompt, completion, depth)
-                else:
-                    logger.info(f"Assistant Message:\n{assistant_message}")
-                    return assistant_message
-
-            return recursive_loop(prompt, completion, depth)
-
-        except Exception as e:
-            logger.error(f"Exception occurred: {e}")
-            raise e

src/prompt_assets/few_shot.json

@@ -1,8 +0,0 @@
-[
-    {
-        "example": "```\nSYSTEM: You are a helpful assistant who has access to functions. Use them if required\n<tools>[\n {\n \"name\": \"calculate_distance\",\n \"description\": \"Calculate the distance between two locations\",\n \"parameters\": {\n \"type\": \"object\",\n \"properties\": {\n \"origin\": {\n \"type\": \"string\",\n \"description\": \"The starting location\"\n },\n \"destination\": {\n \"type\": \"string\",\n \"description\": \"The destination location\"\n },\n \"mode\": {\n \"type\": \"string\",\n \"description\": \"The mode of transportation\"\n }\n },\n \"required\": [\n \"origin\",\n \"destination\",\n \"mode\"\n ]\n }\n },\n {\n \"name\": \"generate_password\",\n \"description\": \"Generate a random password\",\n \"parameters\": {\n \"type\": \"object\",\n \"properties\": {\n \"length\": {\n \"type\": \"integer\",\n \"description\": \"The length of the password\"\n }\n },\n \"required\": [\n \"length\"\n ]\n }\n }\n]\n\n</tools>\nUSER: Hi, I need to know the distance from New York to Los Angeles by car.\nASSISTANT:\n<tool_call>\n{\"arguments\": {\"origin\": \"New York\",\n \"destination\": \"Los Angeles\", \"mode\": \"car\"}, \"name\": \"calculate_distance\"}\n</tool_call>\n```\n"
-    },
-    {
-        "example": "```\nSYSTEM: You are a helpful assistant with access to functions. Use them if required\n<tools>[\n {\n \"name\": \"calculate_distance\",\n \"description\": \"Calculate the distance between two locations\",\n \"parameters\": {\n \"type\": \"object\",\n \"properties\": {\n \"origin\": {\n \"type\": \"string\",\n \"description\": \"The starting location\"\n },\n \"destination\": {\n \"type\": \"string\",\n \"description\": \"The destination location\"\n },\n \"mode\": {\n \"type\": \"string\",\n \"description\": \"The mode of transportation\"\n }\n },\n \"required\": [\n \"origin\",\n \"destination\",\n \"mode\"\n ]\n }\n },\n {\n \"name\": \"generate_password\",\n \"description\": \"Generate a random password\",\n \"parameters\": {\n \"type\": \"object\",\n \"properties\": {\n \"length\": {\n \"type\": \"integer\",\n \"description\": \"The length of the password\"\n }\n },\n \"required\": [\n \"length\"\n ]\n }\n }\n]\n\n</tools>\nUSER: Can you help me generate a random password with a length of 8 characters?\nASSISTANT:\n<tool_call>\n{\"arguments\": {\"length\": 8}, \"name\": \"generate_password\"}\n</tool_call>\n```"
-    }
-]

src/prompt_assets/output_sys_prompt.yml

@@ -1,19 +0,0 @@
-Role: |
-  You are a financial expert named IRAI with experience and expertise in stocks and cryptocurrency.
-  You have a comprehensive understanding of finance, investing, and quantiative analysis; you are a thought leader in these fields.
-  You will be fielding questions about finance from top executives and managers of successful startups.
-  Your audience is high net worth individuals with high risk tolerance and lots of investing experience - they do not need traditional, generic financial advice.
-Objective: |
-  Answer questions as best as accurately as possible given your current knowledge and all available information.
-  Your answers should demonstrate expert insight and indepth analysis. 
-  Use analysis, information, and data from the assistant message to form your answers.
-Instructions: |
-  Answer in a professional and engaging manner representing a top female investment professional working at a leading investment bank.
-  Try to incorprate the numerical data from the function calls to support your analysis, do not state any other numerical data in your answer.
-  Use all the available information to answer the question, including the data and information from the function calls.
-  Do not mention any function calls, such as "get_analysis", "get_current_stock_price", or "get_key_financial_ratios" in your answer.
-  Give a direct answer to question, concise yet insightful.
-  Do not give additional instructions related to seeking financial advisor or professional in your answer.
-  Do not ask any followup questions in your answer.
-  Do not ask for any additional information in your answer.
-  Do not mention Morgan Stanley in your answer.

src/prompt_assets/sys_prompt.yml

@@ -1,39 +0,0 @@
-Role: |
-  You are a function calling AI agent with self-recursion.
-  You will use your comprehensive understanding of finance and investing for function calls.
-  You can call only one function at a time and analyse data you get from function response.
-  You are provided with function signatures within <tools></tools> XML tags.
-  The current date is: {date}.
-Objective: |
-  You may use agentic frameworks for reasoning and planning to help with user questions.
-  Please call a function and wait for function results to be provided to you in the next iteration.
-  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.
-  Analyze the data once you get the results and call another function.
-  At each iteration please continue adding the your analysis to previous summary.
-  Your final response should directly answer the user questions using the results of function calls.
-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.
-Examples: |
-  Here are some example usage of functions:
-  {examples}
-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:
-  <tool_call>
-  {{"arguments": <args-dict>, "name": <function-name>}}
-  </tool_call>

src/prompter.py

@@ -1,76 +0,0 @@
-import datetime
-from pydantic import BaseModel
-from typing import Dict
-from schema import FunctionCall
-from utils import (
-    get_fewshot_examples
-)
-import yaml
-import json
-import os
-
-class PromptSchema(BaseModel):
-    Role: str
-    Objective: str
-    Tools: str
-    Examples: str
-    Schema: str
-    Instructions: str 
-
-class PromptManager:
-    def __init__(self):
-        self.script_dir = os.path.dirname(os.path.abspath(__file__))
-        
-    def format_yaml_prompt(self, prompt_schema: PromptSchema, variables: Dict) -> str:
-        formatted_prompt = ""
-        for field, value in prompt_schema.dict().items():
-            if field == "Examples" and variables.get("examples") is None:
-                continue
-            formatted_value = value.format(**variables)
-            if field == "Instructions":
-                formatted_prompt += f"{formatted_value}"
-            else:
-                formatted_value = formatted_value.replace("\n", " ")
-                formatted_prompt += f"{formatted_value}"
-        return formatted_prompt
-
-    def read_yaml_file(self, file_path: str) -> PromptSchema:
-        with open(file_path, 'r') as file:
-            yaml_content = yaml.safe_load(file)
-        
-        prompt_schema = PromptSchema(
-            Role=yaml_content.get('Role', ''),
-            Objective=yaml_content.get('Objective', ''),
-            Tools=yaml_content.get('Tools', ''),
-            Examples=yaml_content.get('Examples', ''),
-            Schema=yaml_content.get('Schema', ''),
-            Instructions=yaml_content.get('Instructions', ''),
-        )
-        return prompt_schema
-    
-    def generate_prompt(self, user_prompt, tools, num_fewshot=None):
-        prompt_path = os.path.join(self.script_dir, 'prompt_assets', 'sys_prompt.yml')
-        prompt_schema = self.read_yaml_file(prompt_path)
-
-        if num_fewshot is not None:
-            examples = get_fewshot_examples(num_fewshot)
-        else:
-            examples = None
-
-        schema_json = json.loads(FunctionCall.schema_json())
-
-        variables = {
-            "date": datetime.date.today(),
-            "tools": tools,
-            "examples": examples,
-            "schema": schema_json
-        }
-        sys_prompt = self.format_yaml_prompt(prompt_schema, variables)
-
-        prompt = [
-                {'content': sys_prompt, 'role': 'system'}
-            ]
-        prompt.extend(user_prompt)
-        return prompt
-        
-        

src/schema.py

@@ -1,23 +0,0 @@
-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"]

src/utils.py

@@ -1,122 +0,0 @@
-import ast
-import os
-import re
-import json
-import logging
-import datetime
-import xml.etree.ElementTree as ET
-from logger import logger
-
-from logging.handlers import RotatingFileHandler
-
-logging.basicConfig(
-    format="%(asctime)s,%(msecs)03d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s",
-    datefmt="%Y-%m-%d:%H:%M:%S",
-    level=logging.INFO,
-)
-script_dir = os.path.dirname(os.path.abspath(__file__))
-now = datetime.datetime.now()
-log_folder = os.path.join(script_dir, "inference_logs")
-os.makedirs(log_folder, exist_ok=True)
-log_file_path = os.path.join(
-    log_folder, f"function-calling-inference_{now.strftime('%Y-%m-%d_%H-%M-%S')}.log"
-)
-# Use RotatingFileHandler from the logging.handlers module
-file_handler = RotatingFileHandler(log_file_path, maxBytes=0, backupCount=0)
-file_handler.setLevel(logging.INFO)
-
-formatter = logging.Formatter("%(asctime)s,%(msecs)03d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s", datefmt="%Y-%m-%d:%H:%M:%S")
-file_handler.setFormatter(formatter)
-
-def get_fewshot_examples(num_fewshot):
-    """return a list of few shot examples"""
-    example_path = os.path.join(script_dir, 'prompt_assets', 'few_shot.json')
-    with open(example_path, 'r') as file:
-        examples = json.load(file)  # Use json.load with the file object, not the file path
-    if num_fewshot > len(examples):
-        raise ValueError(f"Not enough examples (got {num_fewshot}, but there are only {len(examples)} examples).")
-    return examples[:num_fewshot]
-
-def get_chat_template(chat_template):
-    """read chat template from jinja file"""
-    template_path = os.path.join(script_dir, 'chat_templates', f"{chat_template}.j2")
-
-    if not os.path.exists(template_path):
-        print
-        logger.error(f"Template file not found: {chat_template}")
-        return None
-    try:
-        with open(template_path, 'r') as file:
-            template = file.read()
-        return template
-    except Exception as e:
-        print(f"Error loading template: {e}")
-        return None
-
-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 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

src/validator.py

@@ -1,149 +0,0 @@
-import ast
-import json
-from jsonschema import validate
-from pydantic import ValidationError
-from logger 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