vision-agent 0.2.56__py3-none-any.whl → 0.2.58__py3-none-any.whl

vision_agent/agent/easytool_v2_prompts.py

@@ -1,152 +0,0 @@
-VISION_AGENT_REFLECTION = """You are an advanced reasoning agent that can improve based on self-refection. You will be given a previous reasoning trial in which you were given the user's question, the available tools that the agent has, the decomposed tasks and tools that the agent used to answer the question, the tool usage for each of the tools used and the final answer the agent provided. You may also receive an image with the visualized bounding boxes or masks with their associated labels and scores from the tools used.
-
-Please note that:
-1. You must ONLY output parsible JSON format. If the agents output was correct set "Finish" to true, else set "Finish" to false. An example output looks like:
-{{"Finish": true, "Reflection": "The agent's answer was correct."}}
-2. You must utilize the image with the visualized bounding boxes or masks and determine if the tools were used correctly or if the tools were used incorrectly or the wrong tools were used.
-3. If the agent's answer was incorrect, you must diagnose the reason for failure and devise a new concise and concrete plan that aims to mitigate the same failure with the tools available. An example output looks like:
-    {{"Finish": false, "Reflection": "I can see from the visualized bounding boxes that the agent's answer was incorrect because the grounding_dino_ tool produced false positive predictions. The agent should use the following tools with the following parameters:
-        Step 1: Use 'grounding_dino_' with a 'prompt' of 'baby. bed' and a 'box_threshold' of 0.7 to reduce the false positives.
-        Step 2: Use 'box_iou_' with the baby bounding box and the bed bounding box to determine if the baby is on the bed or not."}}
-4. If the task cannot be completed with the existing tools or by adjusting the parameters, set "Finish" to true.
-
-User's question: {question}
-
-Tools available:
-{tools}
-
-Tasks and tools used:
-{tool_results}
-
-Tool's used API documentation:
-{tool_usage}
-
-Final answer:
-{final_answer}
-
-Reflection: """
-
-TASK_DECOMPOSE = """You need to decompose a user's complex question into one or more simple subtasks and let the model execute it step by step.
-This is the user's question: {question}
-This is the tool list:
-{tools}
-
-Please note that:
-1. If the given task is simple and the answer can be provided by executing one tool, you should only use that tool to provide the answer.
-2. If the given task is complex, You should decompose this user's complex question into simple subtasks which can only be executed easily by using one single tool in the tool list.
-3. You should try to decompose the complex question into least number of subtasks.
-4. If one subtask needs the results from another subtask, you should write clearly. For example:
-{{"Tasks": ["Convert 23 km/h to X km/min by 'divide_'", "Multiply X km/min by 45 min to get Y by 'multiply_'"]}}
-5. You must ONLY output in a parsible JSON format. An example output looks like:
-
-{{"Tasks": ["Task 1", "Task 2", ...]}}
-
-Output: """
-
-TASK_DECOMPOSE_DEPENDS = """You need to decompose a user's complex question into one or more simple subtasks and let the model execute it step by step.
-This is the user's question: {question}
-
-This is the tool list:
-{tools}
-
-This is a reflection from a previous failed attempt:
-{reflections}
-
-Please note that:
-1. If the given task is simple and the answer can be provided by executing one tool, you should only use that tool to provide the answer.
-2. If the given task is complex, You should decompose this user's complex question into simple subtasks which can only be executed easily by using one single tool in the tool list.
-3. You should try to decompose the complex question into least number of subtasks.
-4. If one subtask needs the results from another subtask, you should write clearly. For example:
-{{"Tasks": ["Convert 23 km/h to X km/min by 'divide_'", "Multiply X km/min by 45 min to get Y by 'multiply_'"]}}
-5. You must ONLY output in a parsible JSON format. An example output looks like:
-
-{{"Tasks": ["Task 1", "Task 2", ...]}}
-
-Output: """
-
-CHOOSE_TOOL = """This is the user's question: {question}
-These are the tools you can select to solve the question:
-{tools}
-
-Please note that:
-1. You should only choose one tool from the Tool List to solve this question and it should have maximum chance of solving the question.
-2. You should only choose the tool whose parameters are most relevant to the user's question and are available as part of the question.
-3. You should choose the tool whose return type is most relevant to the answer of the user's question.
-4. You must ONLY output the ID of the tool you chose in a parsible JSON format. Two example outputs look like:
-
-Example 1: {{"ID": 1}}
-Example 2: {{"ID": 2}}
-
-Output: """
-
-CHOOSE_TOOL_DEPENDS = """This is the user's question: {question}
-These are the tools you can select to solve the question:
-{tools}
-
-This is a reflection from a previous failed attempt:
-{reflections}
-
-Please note that:
-1. You should only choose one tool from the Tool List to solve this question and it should have maximum chance of solving the question.
-2. You should only choose the tool whose parameters are most relevant to the user's question and are available as part of the question.
-3. You should choose the tool whose return type is most relevant to the answer of the user's question.
-4. You must ONLY output the ID of the tool you chose in a parsible JSON format. Two example outputs look like:
-
-Example 1: {{"ID": 1}}
-Example 2: {{"ID": 2}}
-
-Output: """
-
-CHOOSE_PARAMETER_DEPENDS = """Given a user's question and an API tool documentation, you need to output parameters according to the API tool documentation to successfully call the API to solve the user's question.
-Please note that:
-1. The Example in the API tool documentation can help you better understand the use of the API. Pay attention to the examples which show how to parse the question and extract tool parameters such as prompts and visual inputs.
-2. Ensure the parameters you output are correct. The output must contain the required parameters, and can contain the optional parameters based on the question. If there are no parameters in the required parameters and optional parameters, just leave it as {{"Parameters":{{}}}}
-3. If the user's question mentions other APIs, you should ONLY consider the API tool documentation I give and do not consider other APIs.
-4. The question may have dependencies on answers of other questions, so we will provide logs of previous questions and answers for your reference.
-5. If you need to use this API multiple times, please set "Parameters" to a list.
-6. You must ONLY output in a parsible JSON format. Two example outputs look like:
-
-Example 1: {{"Parameters":{{"input": [1,2,3]}}}}
-Example 2: {{"Parameters":[{{"input": [1,2,3]}}, {{"input": [2,3,4]}}]}}
-
-This is a reflection from a previous failed attempt:
-{reflections}
-
-These are logs of previous questions and answers:
-{previous_log}
-
-This is the current user's question: {question}
-This is the API tool documentation: {tool_usage}
-Output: """
-
-ANSWER_GENERATE_DEPENDS = """You should answer the question based on the response output by the API tool.
-Please note that:
-1. You should try to organize the response into a natural language answer.
-2. We will not show the API response to the user, thus you need to make full use of the response and give the information in the response that can satisfy the user's question in as much detail as possible.
-3. If the API tool does not provide useful information in the response, please answer with your knowledge.
-4. The question may have dependencies on answers of other questions, so we will provide logs of previous questions and answers.
-
-This is a reflection from a previous failed attempt:
-{reflections}
-
-These are logs of previous questions and answers:
-{previous_log}
-
-This is the user's question: {question}
-
-This is the response output by the API tool:
-{call_results}
-
-We will not show the API response to the user, thus you need to make full use of the response and give the information in the response that can satisfy the user's question in as much detail as possible.
-Output: """
-
-ANSWER_SUMMARIZE_DEPENDS = """We break down a user's complex problems into simple subtasks and provide answers to each simple subtask. You need to organize these answers to each subtask and form a self-consistent final answer to the user's question
-This is the user's question: {question}
-
-These are subtasks and their answers:
-{answers}
-
-This is a reflection from a previous failed attempt:
-{reflections}
-
-Final answer: """

vision_agent/agent/reflexion.py

@@ -1,299 +0,0 @@
-import logging
-import re
-import sys
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
-
-from vision_agent.llm import LLM, OpenAILLM
-from vision_agent.lmm import LMM
-
-from .agent import Agent
-from .reflexion_prompts import (
-    CHECK_FINSH,
-    COT_AGENT_REFLECT_INSTRUCTION,
-    COT_REFLECT_INSTRUCTION,
-    COT_SIMPLE_REFLECTION,
-    COTQA_SIMPLE6,
-    REFLECTION_HEADER,
-)
-
-logging.basicConfig(stream=sys.stdout)
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def format_step(step: str) -> str:
-    return step.strip("\n").strip().replace("\n", "")
-
-
-def parse_action(input: str) -> Tuple[str, str]:
-    # Make the pattern slightly less strict, the LMMs are not as good at following
-    # instructions so they often would fail on the original regex.
-    pattern = r"(\w+)\[(.+)\]"
-    match = re.search(pattern, input)
-
-    if match:
-        action_type = match.group(1)
-        argument = match.group(2)
-        return action_type, argument
-
-    _LOGGER.error(f"Invalid action: {input}")
-    raise ValueError(f"Invalid action: {input}")
-
-
-def format_reflections(reflections: List[str], header: str = REFLECTION_HEADER) -> str:
-    if reflections == []:
-        return ""
-    else:
-        return (
-            header + "Reflections:\n- " + "\n- ".join([r.strip() for r in reflections])
-        )
-
-
-def format_chat(chat: List[Dict[str, str]]) -> str:
-    chat_str = ""
-    for c in chat:
-        chat_str += c["role"] + ": " + c["content"] + "\n"
-    return chat_str.strip()
-
-
-class Reflexion(Agent):
-    r"""This is an implementation of the Reflexion paper https://arxiv.org/abs/2303.11366
-    based on the original implementation https://github.com/noahshinn/reflexion in the
-    hotpotqa folder. There are several differences between this implementation and the
-    original one. Because we do not have instant feedback on whether or not the agent
-    was correct, we use user feedback to determine if the agent was correct. The user
-    feedback is evaluated by the self_reflect_model with a new prompt. We also expand
-    Reflexion to include the ability to use an image as input to the action_agent and the
-    self_reflect_model. Using Reflexion with LMMs may not work well, if it gets it wrong
-    the first time, chances are it can't actually see the thing you want it to see.
-
-    Example
-    -------
-        >>> from vision_agent.agent import Reflexion
-        >>> agent = Reflexion()
-        >>> question = "How many tires does a truck have?"
-        >>> resp = agent(question)
-        >>> print(resp)
-        "18"
-        >>> resp = agent([
-        >>>     {"role": "user", "content": question},
-        >>>     {"role": "assistant", "content": resp},
-        >>>     {"role": "user", "content": "No I mean those regular trucks but where the back tires are double."}
-        >>> ])
-        >>> print(resp)
-        "6"
-        >>> agent = Reflexion(
-        >>>     self_reflect_model=va.lmm.OpenAILMM(),
-        >>>     action_agent=va.lmm.OpenAILMM()
-        >>> )
-        >>> quesiton = "How many hearts are in this image?"
-        >>> resp = agent(question, image="cards.png")
-        >>> print(resp)
-        "6"
-        >>> resp = agent([
-        >>>     {"role": "user", "content": question},
-        >>>     {"role": "assistant", "content": resp},
-        >>>     {"role": "user", "content": "No, please count the hearts on the bottom card."}
-        >>> ], image="cards.png")
-        >>> print(resp)
-        "4"
-        )
-    """
-
-    def __init__(
-        self,
-        cot_examples: str = COTQA_SIMPLE6,
-        reflect_examples: str = COT_SIMPLE_REFLECTION,
-        agent_prompt: str = COT_AGENT_REFLECT_INSTRUCTION,
-        reflect_prompt: str = COT_REFLECT_INSTRUCTION,
-        finsh_prompt: str = CHECK_FINSH,
-        self_reflect_model: Optional[Union[LLM, LMM]] = None,
-        action_agent: Optional[Union[Agent, LLM, LMM]] = None,
-        verbose: bool = False,
-    ):
-        self.agent_prompt = agent_prompt
-        self.reflect_prompt = reflect_prompt
-        self.finsh_prompt = finsh_prompt
-        self.cot_examples = cot_examples
-        self.reflect_examples = reflect_examples
-        self.reflections: List[str] = []
-        if verbose:
-            _LOGGER.setLevel(logging.INFO)
-
-        if isinstance(self_reflect_model, LLM) and not isinstance(action_agent, LLM):
-            raise ValueError(
-                "If self_reflect_model is an LLM, then action_agent must also be an LLM."
-            )
-        if isinstance(self_reflect_model, LMM) and isinstance(action_agent, LLM):
-            raise ValueError(
-                "If self_reflect_model is an LMM, then action_agent must also be an agent or LMM."
-            )
-
-        self.self_reflect_model = (
-            OpenAILLM() if self_reflect_model is None else self_reflect_model
-        )
-        self.action_agent = OpenAILLM() if action_agent is None else action_agent
-
-    def __call__(
-        self,
-        input: Union[str, List[Dict[str, str]]],
-        media: Optional[Union[str, Path]] = None,
-    ) -> str:
-        """Invoke the vision agent.
-
-        Parameters:
-            input: a prompt that describe the task or a conversation in the format of [{"role": "user", "content": "describe your task here..."}].
-            media: the input media referenced in the prompt parameter.
-
-        Returns:
-            A text response.
-        """
-        if isinstance(input, str):
-            input = [{"role": "user", "content": input}]
-        return self.chat(input, media)
-
-    def chat(
-        self, chat: List[Dict[str, str]], media: Optional[Union[str, Path]] = None
-    ) -> str:
-        if len(chat) == 0 or chat[0]["role"] != "user":
-            raise ValueError(
-                f"Invalid chat. Should start with user and alternate between user"
-                f"and assistant and contain at least one entry {chat}"
-            )
-        if media is not None and isinstance(self.action_agent, LLM):
-            raise ValueError(
-                "If image is provided, then action_agent must be an agent or LMM."
-            )
-
-        question = chat[0]["content"]
-        if len(chat) == 1:
-            results = self._step(question, image=media)
-            self.last_scratchpad = results["scratchpad"]
-            return results["action_arg"]
-
-        # Observe
-        chat_str = format_chat(chat)
-        is_correct = self.prompt_finish(chat_str)
-        self.last_scratchpad += "\nObservation: "
-        if is_correct:
-            self.last_scratchpad += "Answer is CORRECT"
-            return self.self_reflect_model(chat)
-        else:
-            self.last_scratchpad += "Answer is INCORRECT"
-            chat_context = "The previous conversation was:\n" + chat_str
-            reflections = self.reflect(
-                question, chat_context, self.last_scratchpad, media
-            )
-            _LOGGER.info(f" {reflections}")
-            results = self._step(question, reflections, image=media)
-            self.last_scratchpad = results["scratchpad"]
-            return results["action_arg"]
-
-    def _step(
-        self,
-        question: str,
-        reflections: str = "",
-        image: Optional[Union[str, Path]] = None,
-    ) -> Dict[str, str]:
-        # Think
-        scratchpad = "\nThought:"
-        scratchpad += " " + self.prompt_agent(question, reflections, scratchpad, image)
-        _LOGGER.info(f" {scratchpad}")
-
-        # Act
-        scratchpad += "\nAction:"
-        action = self.prompt_agent(question, reflections, scratchpad, image)
-        _LOGGER.info(f" {action}")
-        scratchpad += " " + action
-        action_type, argument = parse_action(action)
-        return {
-            "scratchpad": scratchpad,
-            "action_type": action_type,
-            "action_arg": argument,
-        }
-
-    def reflect(
-        self,
-        question: str,
-        context: str,
-        scratchpad: str,
-        image: Optional[Union[str, Path]],
-    ) -> str:
-        self.reflections += [
-            self.prompt_reflection(question, context, scratchpad, image)
-        ]
-        return format_reflections(self.reflections)
-
-    def prompt_agent(
-        self,
-        question: str,
-        reflections: str,
-        scratchpad: str,
-        image: Optional[Union[str, Path]] = None,
-    ) -> str:
-        if isinstance(self.action_agent, LLM):
-            return format_step(
-                self.action_agent(
-                    self._build_agent_prompt(question, reflections, scratchpad)
-                )
-            )
-        elif isinstance(self.action_agent, LMM):
-            return format_step(
-                self.action_agent(
-                    self._build_agent_prompt(question, reflections, scratchpad),
-                    images=[image] if image is not None else None,
-                )
-            )
-        elif isinstance(self.action_agent, Agent):
-            return format_step(
-                self.action_agent(
-                    self._build_agent_prompt(question, reflections, scratchpad),
-                    media=image,
-                )
-            )
-
-    def prompt_reflection(
-        self,
-        question: str,
-        context: str = "",
-        scratchpad: str = "",
-        image: Optional[Union[str, Path]] = None,
-    ) -> str:
-        if isinstance(self.self_reflect_model, LLM):
-            return format_step(
-                self.self_reflect_model(
-                    self._build_reflect_prompt(question, context, scratchpad)
-                )
-            )
-        return format_step(
-            self.self_reflect_model(
-                self._build_reflect_prompt(question, context, scratchpad),
-                images=[image] if image is not None else None,
-            )
-        )
-
-    def prompt_finish(self, chat: str) -> bool:
-        answer = self.action_agent(self.finsh_prompt.format(chat=chat))
-        return "true" in answer.lower()
-
-    def _build_agent_prompt(
-        self, question: str, reflections: str, scratchpad: str
-    ) -> str:
-        return self.agent_prompt.format(
-            examples=self.cot_examples,
-            reflections=reflections,
-            context="",
-            question=question,
-            scratchpad=scratchpad,
-        )
-
-    def _build_reflect_prompt(
-        self, question: str, context: str = "", scratchpad: str = ""
-    ) -> str:
-        return self.reflect_prompt.format(
-            examples=self.reflect_examples,
-            context=context,
-            question=question,
-            scratchpad=scratchpad,
-        )

vision_agent/agent/reflexion_prompts.py

@@ -1,100 +0,0 @@
-COT_AGENT_REFLECT_INSTRUCTION = """Solve a question answering task by having a Thought, then Finish with your answer. Thought can reason about the current situation. Finish[answer] returns the answer and finishes the task. You will be given context that you should use to help you answer the question.
-Here are some examples:
-{examples}
-(END OF EXAMPLES)
-
-{reflections}
-
-Relevant Context: {context}
-Question: {question}{scratchpad}"""
-
-
-COT_REFLECT_INSTRUCTION = """You are an advanced reasoning agent that can improve based on self-refection. You will be given a previous reasoning trial in which you were given access to relevant context and a question to answer. You were unsuccessful in answering the question either because you guessed the wrong answer with Finish[<answer>] or there is a phrasing discrepancy with your provided answer and the answer key. In a few sentences, diagnose a possible reason for failure or phrasing discrepancy and devise a new, concise, high level plan that aims to mitigate the same failure. Use complete sentences.
-Here are some examples:
-{examples}
-(END OF EXAMPLES)
-
-Previous trial:
-Relevant Context: {context}
-Question: {question}{scratchpad}
-
-Reflection:"""
-
-
-REFLECTION_HEADER = "You have attempted to answer following question before and failed. The following reflection(s) give a plan to avoid failing to answer the question in the same way you did previously. Use them to improve your strategy of correctly answering the given question.\n"
-
-
-COT = """Relevant Context: The Nile River is the longest river in the world, spanning approximately 6,650 kilometers (4,132 miles) in length. It flows through eleven countries in northeastern Africa, including Egypt, Sudan, and Uganda.
-Question: What is the longest river in the world?
-Thought: The question asks for the longest river in the world, which I know is the Nile River based on the context provided.
-Action: Finish[Nile River]
-
-Relevant Context: Ludwig van Beethoven was a German composer and pianist who was a crucial figure in the transition between the Classical and Romantic eras in Western classical music. One of his most famous compositions is the Symphony No. 9, also known as the "Choral" symphony.
-Question: Which composer created Symphony No. 9?
-Thought: The question is asking for the composer of Symphony No. 9. Based on the context, I know that Ludwig van Beethoven composed this symphony.
-Action: Finish[Ludwig van Beethoven]
-
-Relevant Context: Photosynthesis is the process by which green plants and some other organisms convert light energy into chemical energy. During this process, plants absorb sunlight, carbon dioxide, and water to produce glucose and oxygen.
-Question: What do plants produce during photosynthesis?
-Thought: The question is asking about the products of photosynthesis. From the context, I know that plants produce glucose and oxygen during this process.
-Action: Finish[Glucose and Oxygen]
-"""
-
-COT_REFLECT = """
-Relevant Context: Ernest Hemingway's novel "The Old Man and the Sea" tells the story of Santiago, an aging Cuban fisherman, who struggles to catch a giant marlin in the Gulf Stream. The book won the Pulitzer Prize for Fiction in 1953 and contributed to Hemingway's Nobel Prize for Literature in 1954.
-Question: Which literary award did "The Old Man and the Sea" contribute to Hemingway winning?
-Thought: The question is asking which award "The Old Man and the Sea" contributed to Hemingway winning. Based on the context, I know the novel won the Pulitzer Prize for Fiction and contributed to his Nobel Prize for Literature.
-Action: Finish[Pulitzer Prize for Fiction]
-
-Reflection: My answer was correct based on the context, but may not be the exact answer stored by the grading environment. Next time, I should try to provide a less verbose answer like "Pulitzer Prize" or "Nobel Prize."
-
-Context: On 14 October 1947, Chuck Yeager, a United States Air Force test pilot, became the first person to break the sound barrier by flying the Bell X-1 experimental aircraft at an altitude of 45,000 feet.
-Charles Elwood "Chuck" Yeager (13 February 1923 - 7 December 2020) was a United States Air Force officer, flying ace, and test pilot. He is best known for becoming the first person to break the sound barrier, which he achieved in the Bell X-1 aircraft named Glamorous Glennis. Yeager was also a distinguished fighter pilot during World War II and was credited with shooting down at least 12 enemy aircraft. In 1973, he was inducted into the National Aviation Hall of Fame for his significant contributions to aviation.
-Question: Who is the first person to break the sound barrier?
-Thought: The question is asking for the first person to break the sound barrier. From the context, I know that Chuck Yeager, a United States Air Force test pilot, was the first person to break the sound barrier.
-Action: Finish[Chuck Yeager]
-
-Reflection: Upon reflecting on the incorrect answer I provided, I realize that I may not have given the full name of the individual in question. In the context, both the given name and the nickname were mentioned, and I only used the nickname in my response. This could have been the reason my answer was deemed incorrect. Moving forward, when attempting this question again or similar questions, I will make sure to include the complete name of the person, which consists of their given name, any middle names, and their nickname (if applicable). This will help ensure that my answer is more accurate and comprehensive."""
-
-COTQA_SIMPLE6 = """
-Question: What is the elevation range for the area that the eastern sector of the Colorado orogeny extends into?
-Thought: Let's think step by step. The eastern sector of Colorado orogeny extends into the High Plains. High Plains rise in elevation from around 1,800 to 7,000 ft, so the answer is 1,800 to 7,000 ft.
-Action: Finish[1,800 to 7,000 ft]
-
-Question: Musician and satirist Allie Goertz wrote a song about the "The Simpsons" character Milhouse, who Matt Groening named after who?
-Thought: Let's think step by step. Milhouse was named after U.S. president Richard Nixon, so the answer is Richard Nixon.
-Action: Finish[Richard Nixon]
-
-Question: Which documentary is about Finnish rock groups, Adam Clayton Powell or The Saimaa Gesture?
-Thought: Let's think step by step. Adam Clayton Powell (film) is a documentary about an African-American politician, not Finnish rock groups. So the documentary about Finnish rock groups must instead be The Saimaa Gesture.
-Action: Finish[The Saimaa Gesture]
-
-Question: What profession does Nicholas Ray and Elia Kazan have in common?
-Thought: Let's think step by step. Professions of Nicholas Ray are director, screenwriter, and actor. Professions of Elia Kazan are director, producer, screenwriter, and actor. So profession Nicholas Ray and Elia Kazan have in common is director, screenwriter, and actor.
-Action: Finish[director, screenwriter, actor]
-
-Question: Which magazine was started first Arthur's Magazine or First for Women?
-Thought: Let's think step by step. Arthur's Magazine was started in 1844. First for Women was started in 1989. 1844 (Arthur's Magazine) < 1989 (First for Women), so Arthur's Magazine was started first.
-Action: Finish[Arthur's Magazine]
-
-Question: Were Pavel Urysohn and Leonid Levin known for the same type of work?
-Thought: Let's think step by step. Pavel Urysohn is a mathematician. Leonid Levin is a mathematician and computer scientist. So Pavel Urysohn and Leonid Levin have the same type of work.
-Action: Finish[Yes]"""
-
-COT_SIMPLE_REFLECTION = """
-Question: What is the elevation range for the area that the eastern sector of the Colorado orogeny extends into?
-Thought: Let's think step by step. The eastern sector of Colorado orogeny extends into the Rocky Mountains. The Rocky Mountains rise in elevation from around 1,800 to 14,000 ft, so the answer is 1,800 to 14,000 ft.
-Action: Finish[1,800 to 14,000 ft]
-
-Reflection: My reasoning for the elevation range of the eastern sector of the Colorado orogeny failed because I incorrectly associated it with the Rocky Mountains instead of the High Plains. In the future, when attempting this question, I should focus on better understanding the geography and geological formations involved in the Colorado orogeny to avoid confusion.
-
-Question: Musician and satirist Allie Goertz wrote a song about the "The Simpsons" character Milhouse, who Matt Groening named after who?
-Thought: Let's think step by step. Milhouse was named after a prominent cartoon character, Mickey Mouse, so the answer is Mickey Mouse.
-Action: Finish[Mickey Mouse]
-
-Reflection: My reasoning for the naming of the character Milhouse in "The Simpsons" failed because I incorrectly assumed that the character was named after a prominent cartoon character, Mickey Mouse. In the future, when attempting this question, I should focus on better researching the background of "The Simpsons" and Matt Groening's influences in naming characters to avoid making incorrect assumptions.
-"""
-
-CHECK_FINSH = """
-You are an advanced reasoning agent, your job is to look at a conversation between a human and another agent and determine if the agent correctly answered the human's quesiton. If the agent correctly answered the question, return True. If the agent did not correctly answer the question or you are unsure, return False.
-{chat}"""

vision_agent/llm/__init__.py

@@ -1 +0,0 @@
-from .llm import LLM, AzureOpenAILLM, OpenAILLM