vision-agent 0.2.26__tar.gz → 0.2.28__tar.gz

{vision_agent-0.2.26 → vision_agent-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vision-agent
-Version: 0.2.26
+Version: 0.2.28
 Summary: Toolset for Vision Agent
 Author: Landing AI
 Author-email: dev@landing.ai

{vision_agent-0.2.26 → vision_agent-0.2.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "vision-agent"
-version = "0.2.26"
+version = "0.2.28"
 description = "Toolset for Vision Agent"
 authors = ["Landing AI <dev@landing.ai>"]
 readme = "README.md"

{vision_agent-0.2.26 → vision_agent-0.2.28}/vision_agent/agent/agent.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Union, Any
 
 
 class Agent(ABC):
@@ -13,7 +13,7 @@ class Agent(ABC):
         pass
 
     @abstractmethod
-    def log_progress(self, description: str) -> None:
+    def log_progress(self, data: Dict[str, Any]) -> None:
         """Log the progress of the agent.
         This is a hook that is intended for reporting the progress of the agent.
         """

{vision_agent-0.2.26 → vision_agent-0.2.28}/vision_agent/agent/agent_coder.py

@@ -3,7 +3,7 @@ import logging
 import os
 import sys
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Union, Any
 
 from rich.console import Console
 from rich.syntax import Syntax
@@ -206,5 +206,5 @@ class AgentCoder(Agent):
 
         return f"{IMPORT_HELPER}\n{code}"
 
-    def log_progress(self, description: str) -> None:
-        _LOGGER.info(description)
+    def log_progress(self, data: Dict[str, Any]) -> None:
+        _LOGGER.info(data)

{vision_agent-0.2.26 → vision_agent-0.2.28}/vision_agent/agent/vision_agent.py

@@ -451,7 +451,7 @@ class VisionAgent(Agent):
         reflect_model: Optional[Union[LLM, LMM]] = None,
         max_retries: int = 2,
         verbose: bool = False,
-        report_progress_callback: Optional[Callable[[str], None]] = None,
+        report_progress_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
     ):
         """VisionAgent constructor.
 
@@ -518,23 +518,23 @@ class VisionAgent(Agent):
             self_reflection=self_reflection,
         )
 
-    def log_progress(self, description: str) -> None:
-        _LOGGER.info(description)
+    def log_progress(self, data: Dict[str, Any]) -> None:
+        _LOGGER.info(data)
         if self.report_progress_callback:
-            self.report_progress_callback(description)
+            self.report_progress_callback(data)
 
     def _report_visualization_via_callback(
         self, images: Sequence[Union[str, Path]]
     ) -> None:
         """This is intended for streaming the visualization images via the callback to the client side."""
         if self.report_progress_callback:
-            self.report_progress_callback("<VIZ>")
+            self.report_progress_callback({"log": "<VIZ>"})
             if images:
                 for img in images:
                     self.report_progress_callback(
-                        f"<IMG>base:64{convert_to_b64(img)}</IMG>"
+                        {"log": f"<IMG>base:64{convert_to_b64(img)}</IMG>"}
                     )
-            self.report_progress_callback("</VIZ>")
+            self.report_progress_callback({"log": "</VIZ>"})
 
     def chat_with_workflow(
         self,
@@ -618,8 +618,8 @@ class VisionAgent(Agent):
                 tool_results["answer"] = answer
                 all_tool_results.append(tool_results)
 
-                self.log_progress(f"\tCall Result: {call_results}")
-                self.log_progress(f"\tAnswer: {answer}")
+                self.log_progress({"log": f"\tCall Result: {call_results}"})
+                self.log_progress({"log": f"\tAnswer: {answer}"})
                 answers.append({"task": task_str, "answer": answer})
                 task_depend[task["id"]]["answer"] = answer  # type: ignore
                 task_depend[task["id"]]["call_result"] = call_results  # type: ignore
@@ -644,18 +644,22 @@ class VisionAgent(Agent):
                     final_answer,
                     reflection_images,
                 )
-                self.log_progress(f"Reflection: {reflection}")
+                self.log_progress({"log": f"Reflection: {reflection}"})
                 parsed_reflection = parse_reflect(reflection)
                 if parsed_reflection["Finish"]:
                     break
                 else:
                     reflections += "\n" + parsed_reflection["Reflection"]
             else:
-                self.log_progress("Self Reflection skipped based on user request.")
+                self.log_progress(
+                    {"log": "Self Reflection skipped based on user request."}
+                )
                 break
         # '<ANSWER>' is a symbol to indicate the end of the chat, which is useful for streaming logs.
         self.log_progress(
-            f"The Vision Agent has concluded this chat. <ANSWER>{final_answer}</ANSWER>"
+            {
+                "log": f"The Vision Agent has concluded this chat. <ANSWER>{final_answer}</ANSWER>"
+            }
         )
 
         if visualize_output:
@@ -718,8 +722,10 @@ class VisionAgent(Agent):
         }
 
         self.log_progress(
-            f"""Going to run the following tool(s) in sequence:
+            {
+                "log": f"""Going to run the following tool(s) in sequence:
 {tabulate(tabular_data=[tool_results], headers="keys", tablefmt="mixed_grid", maxcolwidths=_MAX_TABULATE_COL_WIDTH)}"""
+            }
         )
 
         def parse_tool_results(result: Dict[str, Union[Dict, List]]) -> Any:
@@ -764,7 +770,9 @@ class VisionAgent(Agent):
         else:
             task_list = []
         self.log_progress(
-            f"""Planned tasks:
-{tabulate(task_list, headers="keys", tablefmt="mixed_grid", maxcolwidths=_MAX_TABULATE_COL_WIDTH)}"""
+            {
+                "log": "Planned tasks:",
+                "plan": task_list,
+            }
         )
         return task_list

{vision_agent-0.2.26 → vision_agent-0.2.28}/vision_agent/agent/vision_agent_v2.py

@@ -165,6 +165,7 @@ def write_and_exec_code(
     tool_info: str,
     exec: Execute,
     retrieved_ltm: str,
+    log_progress: Callable[[Dict[str, Any]], None],
     max_retry: int = 3,
     verbosity: int = 0,
 ) -> Tuple[bool, str, str, Dict[str, List[str]]]:
@@ -178,6 +179,23 @@ def write_and_exec_code(
     success, result = exec.run_isolation(code)
     if verbosity == 2:
         _CONSOLE.print(Syntax(code, "python", theme="gruvbox-dark", line_numbers=True))
+        log_progress(
+            {
+                "log": f"Code success: {success}",
+            }
+        )
+        log_progress(
+            {
+                "log": "Code:",
+                "code": code,
+            }
+        )
+        log_progress(
+            {
+                "log": "Result:",
+                "result": str(result),
+            }
+        )
         _LOGGER.info(f"\tCode success: {success}, result: {str(result)}")
     working_memory: Dict[str, List[str]] = {}
     while not success and counter < max_retry:
@@ -204,6 +222,18 @@ def write_and_exec_code(
             _CONSOLE.print(
                 Syntax(code, "python", theme="gruvbox-dark", line_numbers=True)
             )
+            log_progress(
+                {
+                    "log": "Debugging reflection:",
+                    "reflection": reflection,
+                }
+            )
+            log_progress(
+                {
+                    "log": "Result:",
+                    "result": result,
+                }
+            )
             _LOGGER.info(f"\tDebugging reflection: {reflection}, result: {result}")
 
         if success:
@@ -224,6 +254,7 @@ def run_plan(
     exec: Execute,
     code: str,
     tool_recommender: Sim,
+    log_progress: Callable[[Dict[str, Any]], None],
     long_term_memory: Optional[Sim] = None,
     verbosity: int = 0,
 ) -> Tuple[str, str, List[Dict[str, Any]], Dict[str, List[str]]]:
@@ -234,6 +265,9 @@ def run_plan(
     working_memory: Dict[str, List[str]] = {}
 
     for task in active_plan:
+        log_progress(
+            {"log": "Going to run the following task(s) in sequence:", "task": task}
+        )
         _LOGGER.info(
             f"""
 {tabulate(tabular_data=[task], headers="keys", tablefmt="mixed_grid", maxcolwidths=_MAX_TABULATE_COL_WIDTH)}"""
@@ -242,6 +276,7 @@ def run_plan(
         tool_info = "\n".join([e["doc"] for e in tools])
 
         if verbosity == 2:
+            log_progress({"log": f"Tools retrieved: {[e['desc'] for e in tools]}"})
             _LOGGER.info(f"Tools retrieved: {[e['desc'] for e in tools]}")
 
         if long_term_memory is not None:
@@ -258,6 +293,7 @@ def run_plan(
             tool_info,
             exec,
             retrieved_ltm,
+            log_progress,
             verbosity=verbosity,
         )
         if task["type"] == "code":
@@ -271,6 +307,18 @@ def run_plan(
             _CONSOLE.print(
                 Syntax(code, "python", theme="gruvbox-dark", line_numbers=True)
             )
+
+        log_progress(
+            {
+                "log": f"Code success: {success}",
+            }
+        )
+        log_progress(
+            {
+                "log": "Result:",
+                "result": str(result),
+            }
+        )
         _LOGGER.info(f"\tCode success: {success} result: {str(result)}")
 
         task["success"] = success
@@ -308,10 +356,12 @@ class VisionAgentV2(Agent):
         tool_recommender: Optional[Sim] = None,
         long_term_memory: 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)
         self.coder = OpenAILLM(temperature=0.0)
         self.exec = Execute(timeout=timeout)
+        self.report_progress_callback = report_progress_callback
         if tool_recommender is None:
             self.tool_recommender = Sim(TOOLS_DF, sim_key="desc")
         else:
@@ -361,6 +411,12 @@ class VisionAgentV2(Agent):
                     working_code = task["code"]
 
         user_req, plan = write_plan(chat, plan, TOOL_DESCRIPTIONS, self.planner)
+        self.log_progress(
+            {
+                "log": "Plans:",
+                "plan": plan,
+            }
+        )
         _LOGGER.info(
             f"""Plan:
 {tabulate(tabular_data=plan, headers="keys", tablefmt="mixed_grid", maxcolwidths=_MAX_TABULATE_COL_WIDTH)}"""
@@ -379,6 +435,7 @@ class VisionAgentV2(Agent):
                 self.exec,
                 working_code,
                 self.tool_recommender,
+                self.log_progress,
                 self.long_term_memory,
                 self.verbosity,
             )
@@ -393,6 +450,13 @@ class VisionAgentV2(Agent):
 
             retries += 1
 
+        self.log_progress(
+            {
+                "log": f"The Vision Agent V2 has concluded this chat.\nSuccess: {success}",
+                "finished": True,
+            }
+        )
+
         return {
             "code": working_code,
             "test": working_test,
@@ -401,5 +465,7 @@ class VisionAgentV2(Agent):
             "plan": plan,
         }
 
-    def log_progress(self, description: str) -> None:
+    def log_progress(self, data: Dict[str, Any]) -> None:
+        if self.report_progress_callback is not None:
+            self.report_progress_callback(data)
         pass

{vision_agent-0.2.26 → vision_agent-0.2.28}/vision_agent/agent/vision_agent_v3.py

@@ -3,7 +3,7 @@ import json
 import logging
 import sys
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, Dict, List, Optional, Union, cast, Callable
 
 from rich.console import Console
 from rich.syntax import Syntax
@@ -114,6 +114,7 @@ def write_and_test_code(
     coder: LLM,
     tester: LLM,
     debugger: LLM,
+    log_progress: Callable[[Dict[str, Any]], None],
     verbosity: int = 0,
     max_retries: int = 3,
 ) -> Dict[str, Any]:
@@ -131,9 +132,27 @@ def write_and_test_code(
     success, result = _EXECUTE.run_isolation(f"{code}\n{test}")
     if verbosity == 2:
         _LOGGER.info("First 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"First result: {result}")
 
     count = 0
@@ -156,6 +175,12 @@ def write_and_test_code(
 
         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']}"
             )
@@ -164,6 +189,12 @@ def write_and_test_code(
                     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
 
@@ -182,7 +213,10 @@ def write_and_test_code(
 
 
 def retrieve_tools(
-    plan: List[Dict[str, str]], tool_recommender: Sim, verbosity: int = 0
+    plan: List[Dict[str, str]],
+    tool_recommender: Sim,
+    log_progress: Callable[[Dict[str, Any]], None],
+    verbosity: int = 0,
 ) -> str:
     tool_info = []
     tool_desc = []
@@ -191,6 +225,12 @@ def retrieve_tools(
         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)
@@ -206,6 +246,7 @@ class VisionAgentV3(Agent):
         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
@@ -223,6 +264,7 @@ class VisionAgentV3(Agent):
         )
         self.verbosity = verbosity
         self.max_retries = 3
+        self.report_progress_callback = report_progress_callback
 
     def __call__(
         self,
@@ -261,6 +303,12 @@ class VisionAgentV3(Agent):
             )
             plan_i_str = "\n-".join([e["instructions"] for e in plan_i])
             if self.verbosity == 1 or self.verbosity == 2:
+                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)}"""
@@ -269,6 +317,7 @@ class VisionAgentV3(Agent):
             tool_info = retrieve_tools(
                 plan_i,
                 self.tool_recommender,
+                self.log_progress,
                 self.verbosity,
             )
             results = write_and_test_code(
@@ -279,6 +328,7 @@ class VisionAgentV3(Agent):
                 self.coder,
                 self.tester,
                 self.debugger,
+                self.log_progress,
                 verbosity=self.verbosity,
             )
             success = cast(bool, results["success"])
@@ -289,11 +339,24 @@ class VisionAgentV3(Agent):
 
             reflection = reflect(chat, 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})
 
+        self.log_progress(
+            {
+                "log": f"The Vision Agent V3 has concluded this chat.\nSuccess: {success}",
+                "finished": True,
+            }
+        )
+
         return {
             "code": code,
             "test": test,
@@ -301,5 +364,7 @@ class VisionAgentV3(Agent):
             "working_memory": working_memory,
         }
 
-    def log_progress(self, description: str) -> None:
+    def log_progress(self, data: Dict[str, Any]) -> None:
+        if self.report_progress_callback is not None:
+            self.report_progress_callback(data)
         pass