vision-agent 0.2.30__py3-none-any.whl → 0.2.31__py3-none-any.whl

vision_agent-0.2.31.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.1
+Name: vision-agent
+Version: 0.2.31
+Summary: Toolset for Vision Agent
+Author: Landing AI
+Author-email: dev@landing.ai
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: ipykernel (>=6.29.4,<7.0.0)
+Requires-Dist: langsmith (>=0.1.58,<0.2.0)
+Requires-Dist: moviepy (>=1.0.0,<2.0.0)
+Requires-Dist: nbclient (>=0.10.0,<0.11.0)
+Requires-Dist: nbformat (>=5.10.4,<6.0.0)
+Requires-Dist: numpy (>=1.21.0,<2.0.0)
+Requires-Dist: openai (>=1.0.0,<2.0.0)
+Requires-Dist: opencv-python-headless (>=4.0.0,<5.0.0)
+Requires-Dist: pandas (>=2.0.0,<3.0.0)
+Requires-Dist: pillow (>=10.0.0,<11.0.0)
+Requires-Dist: pydantic-settings (>=2.2.1,<3.0.0)
+Requires-Dist: requests (>=2.0.0,<3.0.0)
+Requires-Dist: rich (>=13.7.1,<14.0.0)
+Requires-Dist: scipy (>=1.13.0,<1.14.0)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Requires-Dist: tqdm (>=4.64.0,<5.0.0)
+Requires-Dist: typing_extensions (>=4.0.0,<5.0.0)
+Project-URL: Homepage, https://landing.ai
+Project-URL: documentation, https://github.com/landing-ai/vision-agent
+Project-URL: repository, https://github.com/landing-ai/vision-agent
+Description-Content-Type: text/markdown
+
+<div align="center">
+    <img alt="vision_agent" height="200px" src="https://github.com/landing-ai/vision-agent/blob/main/assets/logo.jpg?raw=true">
+
+# 🔍🤖 Vision Agent
+
+[![](https://dcbadge.vercel.app/api/server/wPdN8RCYew?compact=true&style=flat)](https://discord.gg/wPdN8RCYew)
+![ci_status](https://github.com/landing-ai/vision-agent/actions/workflows/ci_cd.yml/badge.svg)
+[![PyPI version](https://badge.fury.io/py/vision-agent.svg)](https://badge.fury.io/py/vision-agent)
+![version](https://img.shields.io/pypi/pyversions/vision-agent)
+</div>
+
+Vision Agent is a library that helps you utilize agent frameworks to generate code to
+solve your vision task. Many current vision problems can easily take hours or days to
+solve, you need to find the right model, figure out how to use it and program it to
+accomplish the task you want. Vision Agent aims to provide an in-seconds experience by
+allowing users to describe their problem in text and have the agent framework generate
+code to solve the task for them. Check out our discord for updates and roadmaps!
+
+## Documentation
+
+- [Vision Agent Library Docs](https://landing-ai.github.io/vision-agent/)
+
+
+## Getting Started
+### Installation
+To get started, you can install the library using pip:
+
+```bash
+pip install vision-agent
+```
+
+Ensure you have an OpenAI API key and set it as an environment variable (if you are
+using Azure OpenAI please see the Azure setup section):
+
+```bash
+export OPENAI_API_KEY="your-api-key"
+```
+
+### Vision Agent
+You can interact with the agent as you would with any LLM or LMM model:
+
+```python
+>>> from vision_agent.agent import VisionAgent
+>>> agent = VisionAgent()
+>>> code = agent("What percentage of the area of the jar is filled with coffee beans?", media="jar.jpg")
+```
+
+Which produces the following code:
+```python
+from vision_agent.tools import load_image, grounding_sam
+
+def calculate_filled_percentage(image_path: str) -> float:
+    # Step 1: Load the image
+    image = load_image(image_path)
+    
+    # Step 2: Segment the jar
+    jar_segments = grounding_sam(prompt="jar", image=image)
+    
+    # Step 3: Segment the coffee beans
+    coffee_beans_segments = grounding_sam(prompt="coffee beans", image=image)
+    
+    # Step 4: Calculate the area of the segmented jar
+    jar_area = 0
+    for segment in jar_segments:
+        jar_area += segment['mask'].sum()
+    
+    # Step 5: Calculate the area of the segmented coffee beans
+    coffee_beans_area = 0
+    for segment in coffee_beans_segments:
+        coffee_beans_area += segment['mask'].sum()
+    
+    # Step 6: Compute the percentage of the jar area that is filled with coffee beans
+    if jar_area == 0:
+        return 0.0  # To avoid division by zero
+    filled_percentage = (coffee_beans_area / jar_area) * 100
+    
+    # Step 7: Return the computed percentage
+    return filled_percentage
+```
+
+To better understand how the model came up with it's answer, you can run it in debug
+mode by passing in the verbose argument:
+
+```python
+>>> agent = VisionAgent(verbose=2)
+```
+
+You can also have it return more information by calling `chat_with_workflow`:
+
+```python
+>>> results = agent.chat_with_workflow([{"role": "user", "content": "What percentage of the area of the jar is filled with coffee beans?"}], media="jar.jpg")
+>>> print(results)
+{
+    "code": "from vision_agent.tools import ..."
+    "test": "calculate_filled_percentage('jar.jpg')",
+    "test_result": "...",
+    "plan": [{"code": "...", "test": "...", "plan": "..."}, ...],
+    "working_memory": ...,
+}
+```
+
+With this you can examine more detailed information such as the etesting code, testing
+results, plan or working memory it used to complete the task.
+
+### Tools
+There are a variety of tools for the model or the user to use. Some are executed locally
+while others are hosted for you. You can also ask an LLM directly to build a tool for
+you. For example:
+
+```python
+>>> import vision_agent as va
+>>> llm = va.llm.OpenAILLM()
+>>> detector = llm.generate_detector("Can you build a jar detector for me?")
+>>> detector("jar.jpg")
+[{"labels": ["jar",],
+  "scores": [0.99],
+  "bboxes": [
+    [0.58, 0.2, 0.72, 0.45],
+  ]
+}]
+```
+
+### Azure Setup
+If you want to use Azure OpenAI models, you can set the environment variable:
+
+```bash
+export AZURE_OPENAI_API_KEY="your-api-key"
+export AZURE_OPENAI_ENDPOINT="your-endpoint"
+```
+
+You can then run Vision Agent using the Azure OpenAI models:
+
+```python
+>>> import vision_agent as va
+>>> agent = va.agent.VisionAgent(
+>>>     task_model=va.llm.AzureOpenAILLM(),
+>>>     answer_model=va.lmm.AzureOpenAILMM(),
+>>>     reflection_model=va.lmm.AzureOpenAILMM(),
+>>> )
+```
+
+

vision_agent-0.2.31.dist-info/RECORD

@@ -0,0 +1,36 @@
+vision_agent/__init__.py,sha256=GVLHCeK_R-zgldpbcPmOzJat-BkadvkuRCMxDvTIcXs,108
+vision_agent/agent/__init__.py,sha256=iiC5eknTQnv87iSwAoHqBthJ3g2Zm6D0dWbYPDfuQ7A,245
+vision_agent/agent/agent.py,sha256=TXh93MOwmArNRieOkYrhliq1rf7wIkhxvCdTiGhTqFs,538
+vision_agent/agent/agent_coder.py,sha256=MQw8SPeNy1D9tUvB-u60H9ab1eLXnrpV0Ggn7Eq_mIo,6988
+vision_agent/agent/agent_coder_prompts.py,sha256=CJe3v7xvHQ32u3RQAXQga_Tk_4UgU64RBAMHZ3S70KY,5538
+vision_agent/agent/data_interpreter.py,sha256=YCREEHWiyTYpKT8hibotylEkx1kF5AH0k9wnmymwPBY,15143
+vision_agent/agent/data_interpreter_prompts.py,sha256=RDJggOfXwGaEoIcTYGX41ZEayCgYei1AootDOc_SN2g,6134
+vision_agent/agent/easytool.py,sha256=wMa9-tpAaiC4E2ONbidxmMM9YvAOw4_Sypf5mGKco_w,11526
+vision_agent/agent/easytool_prompts.py,sha256=Bikw-PPLkm78dwywTlnv32Y1Tw6JMeC-R7oCnXWLcTk,4656
+vision_agent/agent/easytool_v2.py,sha256=CjY-sSj3abxnSq3ZHZMt-7YvRWDXEZsC6RN8FFIypCA,27274
+vision_agent/agent/easytool_v2_prompts.py,sha256=MZSIwovYgB-f-kdJ6btaNDVXptJn47bfOL3-Zn6NiC0,8573
+vision_agent/agent/reflexion.py,sha256=AlM5AvBJvCslXlYQdZiadq4oVHsNBm3IF_03DglTxRo,10506
+vision_agent/agent/reflexion_prompts.py,sha256=G7UAeNz_g2qCb2yN6OaIC7bQVUkda4m3z42EG8wAyfE,9342
+vision_agent/agent/vision_agent.py,sha256=5Bfxif2sqRKS1ZUlQ4yT468EfevI9CQ6V7_Y6xRbbq0,14992
+vision_agent/agent/vision_agent_prompts.py,sha256=s6T5UnyrKIAcaKqcMudWQOBCHt6Obn9QpX3QtqiDv2I,8034
+vision_agent/fonts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vision_agent/fonts/default_font_ch_en.ttf,sha256=1YM0Z3XqLDjSNbF7ihQFSAIUdjF9m1rtHiNC_6QosTE,1594400
+vision_agent/llm/__init__.py,sha256=BoUm_zSAKnLlE8s-gKTSQugXDqVZKPqYlWwlTLdhcz4,48
+vision_agent/llm/llm.py,sha256=UZ73GqQHE-NKOJWsrOTWfmdHYsbCBkJ5rZ7dhcSCHHw,5951
+vision_agent/lmm/__init__.py,sha256=nnNeKD1k7q_4vLb1x51O_EUTYaBgGfeiCx5F433gr3M,67
+vision_agent/lmm/lmm.py,sha256=NwcZYLTzi95LSMAk0sTtw7G_zBLa9lU-DHM5GUUCiK4,10622
+vision_agent/tools/__init__.py,sha256=1kyJy4euA8t73_ALhKZIUOjVb2A1IyYztu-MJJJ0TYI,505
+vision_agent/tools/easytool_tools.py,sha256=pZc5dQlYINlV4nYbbzsDi3-wauA-fCeD2iGmJUMoUfE,47373
+vision_agent/tools/prompts.py,sha256=V1z4YJLXZuUl_iZ5rY0M5hHc_2tmMEUKr0WocXKGt4E,1430
+vision_agent/tools/tool_utils.py,sha256=wzRacbUpqk9hhfX_Y08rL8qP0XCN2w-8IZoYLi3Upn4,869
+vision_agent/tools/tools.py,sha256=mio0A1l5QcyRC5IgaD4Trfqg7hFTZ8rOjx1dYivwb4Q,21585
+vision_agent/utils/__init__.py,sha256=xsHFyJSDbLdonB9Dh74cwZnVTiT__2OQF3Brd3Nmglc,116
+vision_agent/utils/execute.py,sha256=8_SfK-IkHH4lXF0JVyV7sDFszZn9HKsh1bFITKGCJ1g,3881
+vision_agent/utils/image_utils.py,sha256=_cdiS5YrLzqkq_ZgFUO897m5M4_SCIThwUy4lOklfB8,7700
+vision_agent/utils/sim.py,sha256=oUZ-6eu8Io-UNt9GXJ0XRKtP-Wc0sPWVzYGVpB2yDFk,3001
+vision_agent/utils/type_defs.py,sha256=BlI8ywWHAplC7kYWLvt4AOdnKpEW3qWEFm-GEOSkrFQ,1792
+vision_agent/utils/video.py,sha256=xTElFSFp1Jw4ulOMnk81Vxsh-9dTxcWUO6P9fzEi3AM,7653
+vision_agent-0.2.31.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vision_agent-0.2.31.dist-info/METADATA,sha256=tsCUD6WuSXUt5XLCmOD89DMzDTAxyrCPiA0cAES85AI,5942
+vision_agent-0.2.31.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+vision_agent-0.2.31.dist-info/RECORD,,

vision_agent/agent/vision_agent_v3.py

@@ -1,394 +0,0 @@
-import copy
-import json
-import logging
-import sys
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Union, cast, no_type_check
-
-from rich.console import Console
-from rich.syntax import Syntax
-from tabulate import tabulate
-
-from vision_agent.agent import Agent
-from vision_agent.agent.vision_agent_v3_prompts import (
-    CODE,
-    FEEDBACK,
-    FIX_BUG,
-    FULL_TASK,
-    PLAN,
-    REFLECT,
-    SIMPLE_TEST,
-    USER_REQ,
-)
-from vision_agent.llm import LLM, OpenAILLM
-from vision_agent.tools.tools_v2 import TOOL_DESCRIPTIONS, TOOLS_DF, UTILITIES_DOCSTRING
-from vision_agent.utils import Execute
-from vision_agent.utils.sim import Sim
-
-logging.basicConfig(stream=sys.stdout)
-_LOGGER = logging.getLogger(__name__)
-_MAX_TABULATE_COL_WIDTH = 80
-_EXECUTE = Execute(600)
-_CONSOLE = Console()
-
-
-def format_memory(memory: List[Dict[str, str]]) -> str:
-    return FEEDBACK.format(
-        feedback="\n".join(
-            [
-                f"### Feedback {i}:\nCode: ```python\n{m['code']}\n```\nFeedback: {m['feedback']}\n"
-                for i, m in enumerate(memory)
-            ]
-        )
-    )
-
-
-def extract_code(code: str) -> str:
-    if "\n```python" in code:
-        start = "\n```python"
-    elif "```python" in code:
-        start = "```python"
-    else:
-        return code
-
-    code = code[code.find(start) + len(start) :]
-    code = code[: code.find("```")]
-    if code.startswith("python\n"):
-        code = code[len("python\n") :]
-    return code
-
-
-def extract_json(json_str: str) -> Dict[str, Any]:
-    try:
-        json_dict = json.loads(json_str)
-    except json.JSONDecodeError:
-        if "```json" in json_str:
-            json_str = json_str[json_str.find("```json") + len("```json") :]
-            json_str = json_str[: json_str.find("```")]
-        elif "```" in json_str:
-            json_str = json_str[json_str.find("```") + len("```") :]
-            # get the last ``` not one from an intermediate string
-            json_str = json_str[: json_str.find("}```")]
-        json_dict = json.loads(json_str)
-    return json_dict  # type: ignore
-
-
-def write_plan(
-    chat: List[Dict[str, str]],
-    tool_desc: str,
-    working_memory: str,
-    model: LLM,
-) -> List[Dict[str, str]]:
-    chat = copy.deepcopy(chat)
-    if chat[-1]["role"] != "user":
-        raise ValueError("Last chat message must be from the user.")
-
-    user_request = chat[-1]["content"]
-    context = USER_REQ.format(user_request=user_request)
-    prompt = PLAN.format(context=context, tool_desc=tool_desc, feedback=working_memory)
-    chat[-1]["content"] = prompt
-    return extract_json(model.chat(chat))["plan"]  # type: ignore
-
-
-def reflect(
-    chat: List[Dict[str, str]],
-    plan: str,
-    code: str,
-    model: LLM,
-) -> Dict[str, Union[str, bool]]:
-    chat = copy.deepcopy(chat)
-    if chat[-1]["role"] != "user":
-        raise ValueError("Last chat message must be from the user.")
-
-    user_request = chat[-1]["content"]
-    context = USER_REQ.format(user_request=user_request)
-    prompt = REFLECT.format(context=context, plan=plan, code=code)
-    chat[-1]["content"] = prompt
-    return extract_json(model.chat(chat))
-
-
-def write_and_test_code(
-    task: str,
-    tool_info: str,
-    tool_utils: str,
-    working_memory: str,
-    coder: LLM,
-    tester: LLM,
-    debugger: LLM,
-    log_progress: Callable[[Dict[str, Any]], None],
-    verbosity: int = 0,
-    max_retries: int = 3,
-    input_media: Optional[Union[str, Path]] = None,
-) -> Dict[str, Any]:
-    code = extract_code(
-        coder(CODE.format(docstring=tool_info, question=task, feedback=working_memory))
-    )
-    test = extract_code(
-        tester(
-            SIMPLE_TEST.format(
-                docstring=tool_utils,
-                question=task,
-                code=code,
-                feedback=working_memory,
-                media=input_media,
-            )
-        )
-    )
-
-    success, result = _EXECUTE.run_isolation(f"{code}\n{test}")
-    if verbosity == 2:
-        _LOGGER.info("Initial code and tests:")
-        log_progress(
-            {
-                "log": "Code:",
-                "code": code,
-            }
-        )
-        log_progress(
-            {
-                "log": "Test:",
-                "code": test,
-            }
-        )
-        _CONSOLE.print(
-            Syntax(f"{code}\n{test}", "python", theme="gruvbox-dark", line_numbers=True)
-        )
-        log_progress(
-            {
-                "log": "Result:",
-                "result": result,
-            }
-        )
-        _LOGGER.info(f"Initial result: {result}")
-
-    count = 0
-    new_working_memory = []
-    while not success and count < max_retries:
-        fixed_code_and_test = extract_json(
-            debugger(
-                FIX_BUG.format(
-                    code=code, tests=test, result=result, feedback=working_memory
-                )
-            )
-        )
-        if fixed_code_and_test["code"].strip() != "":
-            code = extract_code(fixed_code_and_test["code"])
-        if fixed_code_and_test["test"].strip() != "":
-            test = extract_code(fixed_code_and_test["test"])
-        new_working_memory.append(
-            {"code": f"{code}\n{test}", "feedback": fixed_code_and_test["reflections"]}
-        )
-
-        success, result = _EXECUTE.run_isolation(f"{code}\n{test}")
-        if verbosity == 2:
-            log_progress(
-                {
-                    "log": f"Debug attempt {count + 1}, reflection:",
-                    "result": fixed_code_and_test["reflections"],
-                }
-            )
-            _LOGGER.info(
-                f"Debug attempt {count + 1}, reflection: {fixed_code_and_test['reflections']}"
-            )
-            _CONSOLE.print(
-                Syntax(
-                    f"{code}\n{test}", "python", theme="gruvbox-dark", line_numbers=True
-                )
-            )
-            log_progress(
-                {
-                    "log": "Debug result:",
-                    "result": result,
-                }
-            )
-            _LOGGER.info(f"Debug result: {result}")
-        count += 1
-
-    if verbosity >= 1:
-        _LOGGER.info("Final code and tests:")
-        _CONSOLE.print(
-            Syntax(f"{code}\n{test}", "python", theme="gruvbox-dark", line_numbers=True)
-        )
-        _LOGGER.info(f"Final Result: {result}")
-
-    return {
-        "code": code,
-        "test": test,
-        "success": success,
-        "test_result": result,
-        "working_memory": new_working_memory,
-    }
-
-
-def retrieve_tools(
-    plan: List[Dict[str, str]],
-    tool_recommender: Sim,
-    log_progress: Callable[[Dict[str, Any]], None],
-    verbosity: int = 0,
-) -> str:
-    tool_info = []
-    tool_desc = []
-    for task in plan:
-        tools = tool_recommender.top_k(task["instructions"], k=2, thresh=0.3)
-        tool_info.extend([e["doc"] for e in tools])
-        tool_desc.extend([e["desc"] for e in tools])
-    if verbosity == 2:
-        log_progress(
-            {
-                "log": "Retrieved tools:",
-                "tools": tool_desc,
-            }
-        )
-        _LOGGER.info(f"Tools: {tool_desc}")
-    tool_info_set = set(tool_info)
-    return "\n\n".join(tool_info_set)
-
-
-class VisionAgentV3(Agent):
-    def __init__(
-        self,
-        timeout: int = 600,
-        planner: Optional[LLM] = None,
-        coder: Optional[LLM] = None,
-        tester: Optional[LLM] = None,
-        debugger: Optional[LLM] = None,
-        tool_recommender: Optional[Sim] = None,
-        verbosity: int = 0,
-        report_progress_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
-    ) -> None:
-        self.planner = (
-            OpenAILLM(temperature=0.0, json_mode=True) if planner is None else planner
-        )
-        self.coder = OpenAILLM(temperature=0.0) if coder is None else coder
-        self.tester = OpenAILLM(temperature=0.0) if tester is None else tester
-        self.debugger = (
-            OpenAILLM(temperature=0.0, json_mode=True) if debugger is None else debugger
-        )
-
-        self.tool_recommender = (
-            Sim(TOOLS_DF, sim_key="desc")
-            if tool_recommender is None
-            else tool_recommender
-        )
-        self.verbosity = verbosity
-        self.max_retries = 2
-        self.report_progress_callback = report_progress_callback
-
-    @no_type_check
-    def __call__(
-        self,
-        input: Union[List[Dict[str, str]], str],
-        image: Optional[Union[str, Path]] = None,
-    ) -> Dict[str, Any]:
-        if isinstance(input, str):
-            input = [{"role": "user", "content": input}]
-        results = self.chat_with_workflow(input, image)
-        results.pop("working_memory")
-        return results
-
-    def chat_with_workflow(
-        self,
-        chat: List[Dict[str, str]],
-        image: Optional[Union[str, Path]] = None,
-        self_reflection: bool = False,
-    ) -> Dict[str, Any]:
-        if len(chat) == 0:
-            raise ValueError("Chat cannot be empty.")
-
-        if image is not None:
-            for chat_i in chat:
-                if chat_i["role"] == "user":
-                    chat_i["content"] += f" Image name {image}"
-
-        code = ""
-        test = ""
-        working_memory: List[Dict[str, str]] = []
-        results = {"code": "", "test": "", "plan": []}
-        plan = []
-        success = False
-        retries = 0
-
-        while not success and retries < self.max_retries:
-            plan_i = write_plan(
-                chat, TOOL_DESCRIPTIONS, format_memory(working_memory), self.planner
-            )
-            plan_i_str = "\n-".join([e["instructions"] for e in plan_i])
-            if self.verbosity >= 1:
-                self.log_progress(
-                    {
-                        "log": "Going to run the following plan(s) in sequence:\n",
-                        "plan": plan_i,
-                    }
-                )
-
-                _LOGGER.info(
-                    f"""
-{tabulate(tabular_data=plan_i, headers="keys", tablefmt="mixed_grid", maxcolwidths=_MAX_TABULATE_COL_WIDTH)}"""
-                )
-
-            tool_info = retrieve_tools(
-                plan_i,
-                self.tool_recommender,
-                self.log_progress,
-                self.verbosity,
-            )
-            results = write_and_test_code(
-                FULL_TASK.format(user_request=chat[0]["content"], subtasks=plan_i_str),
-                tool_info,
-                UTILITIES_DOCSTRING,
-                format_memory(working_memory),
-                self.coder,
-                self.tester,
-                self.debugger,
-                self.log_progress,
-                verbosity=self.verbosity,
-                input_media=image,
-            )
-            success = cast(bool, results["success"])
-            code = cast(str, results["code"])
-            test = cast(str, results["test"])
-            working_memory.extend(results["working_memory"])  # type: ignore
-            plan.append({"code": code, "test": test, "plan": plan_i})
-
-            if self_reflection:
-                reflection = reflect(
-                    chat,
-                    FULL_TASK.format(
-                        user_request=chat[0]["content"], subtasks=plan_i_str
-                    ),
-                    code,
-                    self.planner,
-                )
-                if self.verbosity > 0:
-                    self.log_progress(
-                        {
-                            "log": "Reflection:",
-                            "reflection": reflection,
-                        }
-                    )
-                    _LOGGER.info(f"Reflection: {reflection}")
-                feedback = cast(str, reflection["feedback"])
-                success = cast(bool, reflection["success"])
-                working_memory.append({"code": f"{code}\n{test}", "feedback": feedback})
-
-            retries += 1
-
-        self.log_progress(
-            {
-                "log": f"The Vision Agent V3 has concluded this chat.\nSuccess: {success}",
-                "finished": True,
-            }
-        )
-
-        return {
-            "code": code,
-            "test": test,
-            "test_result": results["test_result"],
-            "plan": plan,
-            "working_memory": working_memory,
-        }
-
-    def log_progress(self, data: Dict[str, Any]) -> None:
-        if self.report_progress_callback is not None:
-            self.report_progress_callback(data)
-        pass