versionhq 1.2.4.1__py3-none-any.whl → 1.2.4.2__py3-none-any.whl

versionhq/task/model.py

@@ -4,10 +4,9 @@ import datetime
 import uuid
 import inspect
 import enum
-from textwrap import dedent
 from concurrent.futures import Future
 from hashlib import md5
-from typing import Any, Dict, List, Set, Optional, Callable, Type
+from typing import Any, Dict, List, Set, Optional, Callable, Type, Tuple
 from typing_extensions import Annotated, Self
 
 from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, InstanceOf, field_validator
@@ -16,7 +15,7 @@ from pydantic_core import PydanticCustomError
 import versionhq as vhq
 from versionhq.task.evaluation import Evaluation, EvaluationItem
 from versionhq.tool.model import Tool, ToolSet
-from versionhq._utils import process_config, Logger, is_valid_url
+from versionhq._utils import process_config, Logger
 
 
 class TaskExecutionType(enum.Enum):
@@ -175,6 +174,7 @@ class TaskOutput(BaseModel):
     """
     A class to store the final output of the given task in raw (string), json_dict, and pydantic class formats.
     """
+
     _tokens: int = PrivateAttr(default=0)
 
     task_id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="store Task ID")
@@ -188,18 +188,18 @@ class TaskOutput(BaseModel):
 
 
     def _to_context_prompt(self) -> str:
-        """
-        Returns response in string as a prompt context.
-        """
+        """Formats prompt context in text formats from the final response."""
+
         context = ""
-        try:
-            context = json.dumps(self.json_dict)
-        except:
-            try:
-                if self.pydantic:
-                    context = self.pydantic.model_dump()
-            except:
-                context = self.raw
+        match self.final:
+            case dict() | self.pydantic:
+                try:
+                    context = json.dumps(self.final)
+                except:
+                    context = str(self.final)
+            case _:
+                context = str(self.final)
+
         return context
 
 
@@ -252,6 +252,24 @@ class TaskOutput(BaseModel):
         return self.evaluation
 
 
+    @property
+    def final(self) -> Any:
+        """Returns final output from the task."""
+
+        output = None
+
+        if self.callback_output:
+            output = self.callback_output
+
+        elif self.tool_output and str(self.tool_output) == self.raw: # tool_output_as_final
+            output = self.tool_output
+
+        else:
+            output = self.pydantic if self.pydantic else self.json_dict if self.json_dict else self.raw
+
+        return output
+
+
     @property
     def aggregate_score(self) -> float | int:
         return self.evaluation.aggregate_score if self.evaluation is not None else 0
@@ -280,6 +298,7 @@ class Task(BaseModel):
     description: str = Field(description="Description of the actual task")
 
     # response format
+    response_schema: Optional[Type[BaseModel] | List[ResponseField]] = Field(default=None)
     pydantic_output: Optional[Type[BaseModel]] = Field(default=None, description="store Pydantic class as structured response format")
     response_fields: Optional[List[ResponseField]] = Field(default_factory=list, description="store list of ResponseField as structured response format")
 
@@ -292,6 +311,11 @@ class Task(BaseModel):
     file: Optional[str] = Field(default=None, description="absolute file path or url in string")
     audio: Optional[str] = Field(default=None,  description="absolute file path or url in string")
 
+    # test run
+    should_test_run: bool = Field(default=False)
+    human: bool = Field(default=False)
+    _pfg: Any = None
+
     # executing
     execution_type: TaskExecutionType = Field(default=TaskExecutionType.SYNC)
     allow_delegation: bool = Field(default=False, description="whether to delegate the task to another agent")
@@ -351,121 +375,6 @@ class Task(BaseModel):
         return self
 
 
-    def _draft_output_prompt(self, model_provider: str = None) -> str:
-        output_prompt = ""
-
-        if self.pydantic_output:
-            output_prompt, output_formats_to_follow = "", dict()
-            response_format = str(self._structure_response_format(model_provider=model_provider))
-            for k, v in self.pydantic_output.model_fields.items():
-                output_formats_to_follow[k] = f"<Return your answer in {v.annotation}>"
-
-            output_prompt = f"""Your response MUST be a valid JSON string that strictly follows the response format. Use double quotes for all keys and string values. Do not use single quotes, trailing commas, or any other non-standard JSON syntax.
-Response format: {response_format}
-Ref. Output image: {output_formats_to_follow}
-"""
-        elif self.response_fields:
-            output_prompt, output_formats_to_follow = "", dict()
-            response_format = str(self._structure_response_format(model_provider=model_provider))
-            for item in self.response_fields:
-                if item:
-                    output_formats_to_follow[item.title] = f"<Return your answer in {item.data_type.__name__}>"
-
-            output_prompt = f"""Your response MUST be a valid JSON string that strictly follows the response format. Use double quotes for all keys and string values. Do not use single quotes, trailing commas, or any other non-standard JSON syntax.
-Response format: {response_format}
-Ref. Output image: {output_formats_to_follow}
-"""
-        # elif not self.tools or self.can_use_agent_tools == False:
-        else:
-            output_prompt = "You MUST return your response as a valid JSON serializable string, enclosed in double quotes. Use double quotes for all keys and string values. Do NOT use single quotes, trailing commas, or other non-standard JSON syntax."
-
-        # else:
-        #     output_prompt = "You will return a response in a concise manner."
-
-        return dedent(output_prompt)
-
-
-    def _draft_context_prompt(self, context: Any) -> str:
-        """
-        Create a context prompt from the given context in any format: a task object, task output object, list, dict.
-        """
-
-        context_to_add = None
-        if not context:
-            # Logger().log(level="error", color="red", message="Missing a context to add to the prompt. We'll return ''.")
-            return context_to_add
-
-        match context:
-            case str():
-                context_to_add = context
-
-            case Task():
-                if not context.output:
-                    res = context.execute()
-                    context_to_add = res._to_context_prompt()
-
-                else:
-                    context_to_add = context.output.raw
-
-            case TaskOutput():
-                context_to_add = context._to_context_prompt()
-
-
-            case dict():
-                context_to_add = str(context)
-
-            case list():
-                res = ", ".join([self._draft_context_prompt(context=item) for item in context])
-                context_to_add = res
-
-            case _:
-                pass
-
-        return dedent(context_to_add)
-
-
-    def _user_prompt(self, model_provider: str = None, context: Optional[Any] = None) -> str:
-        """
-        Format the task prompt and cascade it to the agent.
-        """
-        output_prompt = self._draft_output_prompt(model_provider=model_provider)
-        task_slices = [self.description, output_prompt, ]
-
-        if context:
-            context_prompt = self._draft_context_prompt(context=context)
-            task_slices.insert(len(task_slices), f"Consider the following context when responding: {context_prompt}")
-
-        return "\n".join(task_slices)
-
-
-    def _format_content_prompt(self) -> Dict[str, str]:
-        """Formats content (file, image, audio) prompts that added to the messages sent to the LLM."""
-
-        from pathlib import Path
-        import base64
-
-        content_messages = {}
-
-        if self.image:
-            with open(self.image, "rb") as file:
-                content = file.read()
-                if content:
-                    encoded_file = base64.b64encode(content).decode("utf-8")
-                    img_url = f"data:image/jpeg;base64,{encoded_file}"
-                    content_messages.update({ "type": "image_url", "image_url": { "url": img_url }})
-
-        if self.file:
-            if is_valid_url(self.file):
-                content_messages.update({ "type": "image_url", "image_url": self.file })
-
-        if self.audio:
-            audio_bytes = Path(self.audio).read_bytes()
-            encoded_data = base64.b64encode(audio_bytes).decode("utf-8")
-            content_messages.update({  "type": "image_url", "image_url": "data:audio/mp3;base64,{}".format(encoded_data)})
-
-        return content_messages
-
-
     def _structure_response_format(self, data_type: str = "object", model_provider: str = "gemini") -> Dict[str, Any] | None:
         """Structures `response_fields` or `pydantic_output` to a LLM response format."""
 
@@ -495,7 +404,6 @@ Ref. Output image: {output_formats_to_follow}
                     "json_schema": { "name": "outcome", "schema": response_schema }
                 }
 
-
             elif self.pydantic_output:
                 response_format = StructuredOutput(response_format=self.pydantic_output, provider=model_provider)._format()
 
@@ -673,23 +581,32 @@ Ref. Output image: {output_formats_to_follow}
 
 
     # task execution
-    def execute(
-            self, type: TaskExecutionType = None, agent: Optional["vhq.Agent"] = None, context: Optional[Any] = None
-        ) -> TaskOutput | Future[TaskOutput]:
-        """
-        A main method to handle task execution. Build an agent when the agent is not given.
-        """
+    def execute(self, type: TaskExecutionType = None, agent: "vhq.Agent" = None, context: Any = None) -> TaskOutput | Future[TaskOutput]:
+        """A main method to handle task execution."""
+
         type = type if type else  self.execution_type if self.execution_type else TaskExecutionType.SYNC
+        agent = agent if agent else self._build_agent_from_task(task_description=self.description)
+        res = None
 
-        if not agent:
-            agent = self._build_agent_from_task(task_description=self.description)
+        if (self.should_test_run or agent.self_learn) and not self._pfg:
+            res = self._test_time_computation(agent=agent, context=context)
+            return res
+
+        # if self._pfg:
+        #     res, all_outputs = self.pfg.activate()
+        #     tokens, latency = self.pfg.usage
+        #     self._tokens = tokens
+        #     res.latency = latency
+        #     return res
 
         match type:
             case TaskExecutionType.SYNC:
-                return self._execute_sync(agent=agent, context=context)
+                res = self._execute_sync(agent=agent, context=context)
 
             case TaskExecutionType.ASYNC:
-                return self._execute_async(agent=agent, context=context)
+                res = self._execute_async(agent=agent, context=context)
+
+        return res
 
 
     def _execute_sync(self, agent, context: Optional[Any] = None) -> TaskOutput:
@@ -710,14 +627,14 @@ Ref. Output image: {output_formats_to_follow}
 
 
     def _execute_core(self, agent, context: Optional[Any]) -> TaskOutput:
-        """
-        A core method to execute a task.
-        """
+        """A core method to execute a single task."""
+
         task_output: InstanceOf[TaskOutput] = None
         raw_output: str = None
         tool_output: str | list = None
         task_tools: List[List[InstanceOf[Tool]| InstanceOf[ToolSet] | Type[Tool]]] = []
         started_at, ended_at = datetime.datetime.now(), datetime.datetime.now()
+        user_prompt, dev_prompt = None, None
 
         if self.tools:
             for item in self.tools:
@@ -731,14 +648,14 @@ Ref. Output image: {output_formats_to_follow}
 
         if self.tool_res_as_final == True:
             started_at = datetime.datetime.now()
-            tool_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
+            user_prompt, dev_prompt, tool_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
             raw_output = str(tool_output) if tool_output else ""
             ended_at = datetime.datetime.now()
             task_output = TaskOutput(task_id=self.id, tool_output=tool_output, raw=raw_output)
 
         else:
             started_at = datetime.datetime.now()
-            raw_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
+            user_prompt, dev_prompt, raw_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
             ended_at = datetime.datetime.now()
 
             json_dict_output = self._create_json_output(raw=raw_output)
@@ -767,6 +684,11 @@ Ref. Output image: {output_formats_to_follow}
         #     )
         #     self._save_file(content)
 
+        if self._pfg:
+            index = self._pfg.index
+            self._pfg.user_prompts.update({ index: user_prompt })
+            self._pfg.dev_prompts.update({ index: dev_prompt })
+
         if raw_output:
             if self.should_evaluate:
                 task_output.evaluate(task=self)
@@ -787,6 +709,31 @@ Ref. Output image: {output_formats_to_follow}
         return task_output
 
 
+    def _test_time_computation(self, agent, context: Optional[Any]) -> TaskOutput | None:
+        """Handles test-time computation."""
+
+        from versionhq.task_graph.model import ReformTriggerEvent
+        from versionhq._prompt.model import Prompt
+        from versionhq._prompt.auto_feedback import PromptFeedbackGraph
+
+        prompt = Prompt(task=self, agent=agent, context=context)
+        pfg = PromptFeedbackGraph(prompt=prompt, should_reform=self.human, reform_trigger_event=ReformTriggerEvent.USER_INPUT if self.human else None)
+        pfg = pfg.set_up_graph()
+        self._pfg = pfg
+
+        # try:
+        if self._pfg and self.output is None:
+            res, _ = self._pfg.activate()
+            tokens, latency = self._pfg.usage
+            self._tokens = tokens
+            res.latency = latency
+            return res
+
+        # except:
+        #     Logger().log(level="error", message="Failed to execute the task.", color="red")
+        #     return None, None
+
+
     @property
     def key(self) -> str:
         output_format = "json" if self.response_fields else "pydantic" if self.pydantic_output is not None else "raw"

versionhq/task_graph/draft.py

@@ -10,7 +10,7 @@ sys.modules['pydantic.main'].ModelMetaclass = ModelMetaclass
 
 from versionhq.agent.model import Agent
 from versionhq.task.model import ResponseField
-from versionhq.task_graph.model import TaskGraph, Task, DependencyType, Node
+from versionhq.task_graph.model import TaskGraph, Task, DependencyType, Node, ReformTriggerEvent
 from versionhq._utils.logger import Logger
 
 
@@ -81,7 +81,8 @@ def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = F
         nodes={node.identifier: node for node in nodes},
         concl_format=final_output,
         concl=None,
-        should_reform=True,
+        should_reform=human,
+        reform_trigger_event=ReformTriggerEvent.USER_INPUT if human else None,
     )
 
     for res in task_items:
@@ -97,15 +98,4 @@ def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = F
 
     task_graph.visualize()
 
-    if human:
-        print('Proceed? Y/n:')
-        x = input()
-
-        if x.lower() == "y":
-            print("ok. generating agent network")
-
-        else:
-            request = input("request?")
-            print('ok. regenerating the graph based on your input: ', request)
-
     return task_graph

versionhq/task_graph/model.py

@@ -15,7 +15,14 @@ from pydantic_core import PydanticCustomError
 
 from versionhq.agent.model import Agent
 from versionhq.task.model import Task, TaskOutput, Evaluation
-from versionhq._utils.logger import Logger
+from versionhq._utils import Logger
+
+
+class ReformTriggerEvent(enum.Enum):
+    USER_INPUT = 1 # ask human
+    TEST_TIME_COMPUTATION = 2 # mismatch between actual responses and expected outcome
+    ERROR_DETECTION = 3 # response error
+
 
 class ConditionType(enum.Enum):
     AND = 1
@@ -46,7 +53,6 @@ class Condition(BaseModel):
                 res = method(**args) if args else method()
                 return res
 
-
     def condition_met(self) -> bool:
         if not self.methods:
             return True
@@ -54,7 +60,6 @@ class Condition(BaseModel):
         if len(self.methods) == 1:
             for k, v in self.methods.items():
                return self._execute_method(key=k, method=v)
-
         else:
             cond_list = []
             for k, v in self.methods.items():
@@ -96,8 +101,8 @@ class Node(BaseModel):
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     task: InstanceOf[Task] = Field(default=None)
-    in_degree_nodes: List[Any] = Field(default_factory=list, description="list of Node objects")
-    out_degree_nodes: List[Any] = Field(default_factory=list, description="list of Node objects")
+    in_degree_nodes: List["Node"] = Field(default_factory=list, description="list of Node objects")
+    out_degree_nodes: List["Node"] = Field(default_factory=list, description="list of Node objects")
     assigned_to: InstanceOf[Agent] = Field(default=None)
     status: TaskStatus = Field(default=TaskStatus.NOT_STARTED)
 
@@ -107,29 +112,31 @@ class Node(BaseModel):
         if v:
             raise PydanticCustomError("may_not_set_field", "This field is not to be set by client.", {})
 
-
     def is_independent(self) -> bool:
         return not self.in_degree_nodes and not self.out_degree_nodes
 
     def handle_task_execution(self, agent: Agent = None, context: str = None, response_format: Type[BaseModel] = None) -> TaskOutput | None:
         """Executes the task and updates its status"""
 
-        self.status = TaskStatus.IN_PROGRESS
-
         if not self.task:
             Logger().log(level="error", message="Missing a task to execute. We'll return None.", color="red")
             self.status = TaskStatus.ERROR
             return None
 
-        agent = agent if agent else self.assigned_to
-        self.task.pydantic_output = self.task.pydantic_output if self.task.pydantic_output else response_format if type(response_format) == BaseModel else None
-        res = self.task.execute(agent=agent, context=context)
+        if self.status == TaskStatus.COMPLETED:
+            return self.task.output
 
-        if isinstance(res, Future): # activate async
-            res = res.result()
+        else:
+            self.status = TaskStatus.IN_PROGRESS
+            agent = agent if agent else self.assigned_to
+            self.task.pydantic_output = self.task.pydantic_output if self.task.pydantic_output else response_format if type(response_format) == BaseModel else None
+            res = self.task.execute(agent=agent, context=context)
 
-        self.status = TaskStatus.COMPLETED if res else TaskStatus.ERROR
-        return res
+            if isinstance(res, Future): # activate async
+                res = res.result()
+
+            self.status = TaskStatus.COMPLETED if res else TaskStatus.ERROR
+            return res
 
     @property
     def in_degrees(self) -> int:
@@ -238,7 +245,6 @@ class Edge(BaseModel):
         """
         Activates the edge to initiate task execution of the target node.
         """
-
         if not self.source or not self.target:
             Logger(verbose=True).log(level="warning", message="Cannot find source or target nodes. We'll return None.", color="yellow")
             return None
@@ -251,10 +257,11 @@ class Edge(BaseModel):
             import time
             time.sleep(self.lag)
 
-        context = self.source.task.output.raw if self.data_transfer else None
+        context = self.source.task.output._to_context_prompt() if self.data_transfer else None
         res = self.target.handle_task_execution(context=context, response_format=response_format)
         return res
 
+
     @property
     def label(self):
         """Human friendly label for visualization."""
@@ -283,6 +290,14 @@ class Graph(ABC, BaseModel):
         else:
             return None
 
+    def _format_Graph(self) -> None:
+        """Formats dxGraph using edges and nodes."""
+        edges, nodes = [k for k in self.edges.keys()], [k for k in self.nodes.keys()]
+        if self.graph:
+            self.graph.update(edges=edges, nodes=nodes)
+        else:
+            self.graph = nx.Graph(directed=self.directed, edges=edges, nodes=nodes)
+
     def add_node(self, node: Node) -> None:
         if node.identifier in self.nodes.keys():
             return
@@ -333,13 +348,14 @@ class Graph(ABC, BaseModel):
         critical_edge = max(edges, key=lambda item: item['weight']) if edges else None
         return critical_edge.target if critical_edge else None
 
-    def find_path(self, source: Optional[str] | None, target: str, weight: Optional[Any] | None) -> Any:
+    def find_path(self, target: str, source: Optional[str] = None, weight: Optional[Any] = None) -> Any:
         try:
+            self._format_Graph()
             return nx.shortest_path(self.graph, source=source, target=target, weight=weight)
-        except nx.NetworkXNoPath:
+        except:
             return None
 
-    def find_all_paths(self,  source: str, target: str) -> List[Any]:
+    def find_all_paths(self, source: str, target: str) -> List[Any]:
         return list(nx.all_simple_paths(self.graph, source=source, target=target))
 
     def find_critical_path(self) -> tuple[List[Any], int, Dict[str, int]]:
@@ -378,7 +394,8 @@ class Graph(ABC, BaseModel):
 
 class TaskGraph(Graph):
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
-    should_reform: bool = Field(default=False)
+    should_reform: bool = False
+    reform_trigger_event: Optional[ReformTriggerEvent] = None
     outputs: Dict[str, TaskOutput] = Field(default_factory=dict, description="stores node identifier and TaskOutput")
     concl_template: Optional[Dict[str, Any] | Type[BaseModel]] = Field(default=None, description="stores final response format in Pydantic class or JSON dict")
     concl: Optional[TaskOutput] = Field(default=None, description="stores the final or latest conclusion of the entire task graph")
@@ -432,10 +449,8 @@ class TaskGraph(Graph):
         """
         Add an edge that connect task 1 (source) and task 2 (target) using task_node.name as an identifier
         """
-
-        if not edge_attributes:
-            Logger().log(level="error", message="Edge attributes are missing.", color="red")
-
+        # if not edge_attributes:
+        #     Logger().log(level="error", message="Edge attributes are missing.", color="red")
         edge = Edge()
         for k in Edge.model_fields.keys():
             v = edge_attributes.get(k, None)
@@ -443,7 +458,6 @@ class TaskGraph(Graph):
                 setattr(edge, k, v)
             else:
                 pass
-
         self.add_edge(source, target, edge)
 
 
@@ -554,15 +568,10 @@ class TaskGraph(Graph):
 
             # find a shortest path to each in-degree node of the node and see if dependency met.
             node = self._return_node_object(target)
-            sources = node.in_degrees
-            edge_status = []
+            edges = [v for k, v in self.edges.items() if v.target.identifier == node.identifier]
             res = None
 
-            for item in sources:
-                edge = self.find_path(source=item, target=target)
-                edge_status.append(dict(edge=edge if edge else None, dep_met=edge.dependency_met() if edge else False))
-
-            if len([item for item in edge_status if item["dep_met"] == True]) == len(sources):
+            if not edges or len([item for item in edges if item.dependency_met()]) == len(edges):
                 res = node.handle_task_execution()
                 self.outputs.update({ target: res })
 
@@ -598,7 +607,7 @@ class TaskGraph(Graph):
                                     res = node.handle_task_execution()
                                     self.outputs.update({ node.identifier: res })
                 else:
-                    for k, edge in self.edges.items():
+                    for edge in self.edges.values():
                         res = edge.activate()
                         node_identifier = edge.target.identifier
                         self.outputs.update({ node_identifier: res })
@@ -614,6 +623,15 @@ class TaskGraph(Graph):
                     node_identifier = edge.target.identifier
                     self.outputs.update({ node_identifier: res })
 
+
+            if self.should_reform:
+                target = [k for k in self.outputs.keys()][-1] if self.outputs else self.find_start_nodes()[0].identifier if self.find_start_nodes() else None
+
+                if not target:
+                    pass
+                else:
+                    res, _ = self.handle_reform(target=target)
+
             self.concl = res
             self.concl_template = self.concl_template if self.concl_template else res.pydantic.__class__ if res.pydantic else None
              # last_task_output = [v for v in self.outputs.values()][len([v for v in self.outputs.values()]) - 1] if [v for v in self.outputs.values()] else None
@@ -639,6 +657,44 @@ class TaskGraph(Graph):
         return eval
 
 
+    def _handle_human_input(self) -> str | None:
+        """Handles input from human."""
+        request = None
+
+        print('Proceed? Y/n:')
+        x = input()
+
+        if x.lower() == "y":
+            Logger().log(message="Ok, proceeding to the next graph execution.", level="info", color="blue")
+
+        else:
+            request = input("Request?")
+
+            if request:
+                Logger().log(message=f"Ok. regenerating the graph based on your input: ', {request}", level="info", color="blue")
+            else:
+                Logger().log(message="Cannot recognize your request.", level="error", color="red")
+
+        return request
+
+
+    def handle_reform(self, target: str = None) -> Self:
+        task_description = "Improve the given output: "
+        if target:
+            output = self.outputs[target].raw if self.outputs and target in self.outputs else None
+            if output:
+                task_description += str(output)
+
+        if self.reform_trigger_event == ReformTriggerEvent.USER_INPUT:
+            request = self._handle_human_input()
+            task_description += f"You MUST follow the instruction: {request}"
+
+        new_node = Node(task=Task(description=task_description))
+        self.add_node(node=new_node)
+        self.add_dependency(source=target, target=new_node.identifier)
+        return self.activate(target=new_node.identifier)
+
+
     @property
     def usage(self) -> Tuple[int, float]:
         """Returns aggregate number of consumed tokens and job latency in ms during the activation"""

{versionhq-1.2.4.1.dist-info → versionhq-1.2.4.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.4.1
-Summary: A Python framework for autonomous agent networks that handle task automation with multi-step reasoning.
+Version: 1.2.4.2
+Summary: Autonomous agent networks for task automation with multi-step reasoning.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
         
@@ -29,7 +29,7 @@ Project-URL: Homepage, https://versi0n.io
 Project-URL: Documentation, https://docs.versi0n.io
 Project-URL: Repository, https://github.com/versionHQ/multi-agent-system
 Project-URL: Issues, https://github.com/versionHQ/multi-agent-system/issues
-Keywords: orchestration framework,orchestration,ai agent,multi-agent system,RAG,agent,agentic orchestration,llm
+Keywords: autonomic agent networks,deep agent,agentic orchestration framework
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -47,12 +47,9 @@ License-File: LICENSE
 Requires-Dist: regex==2024.11.6
 Requires-Dist: requests>=2.32.3
 Requires-Dist: pydantic>=2.10.6
-Requires-Dist: werkzeug>=3.1.3
 Requires-Dist: typing>=0.0.0
 Requires-Dist: json-repair>=0.0.0
 Requires-Dist: litellm>=1.55.8
-Requires-Dist: openai>=1.64.0
-Requires-Dist: composio-openai>=0.6.9
 Requires-Dist: composio>=0.1.0
 Requires-Dist: setuptools>=75.6.0
 Requires-Dist: wheel>=0.45.1
@@ -60,10 +57,8 @@ Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: langchain>=0.3.14
 Requires-Dist: langchain-openai>=0.2.14
-Requires-Dist: composio-langchain>=0.6.12
 Requires-Dist: chromadb>=0.6.3
 Requires-Dist: wheel>=0.45.1
-Requires-Dist: envoy>=0.0.3
 Requires-Dist: composio-core==0.7.0
 Requires-Dist: networkx>=3.4.2
 Requires-Dist: matplotlib>=3.10.0