versionhq 1.1.10.2__tar.gz → 1.1.10.3__tar.gz

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.1.10.2
+Version: 1.1.10.3
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/pyproject.toml

@@ -15,7 +15,7 @@ exclude = ["test*", "__pycache__"]
 
 [project]
 name = "versionhq"
-version = "1.1.10.2"
+version = "1.1.10.3"
 authors = [{ name = "Kuriko Iwai", email = "kuriko@versi0n.io" }]
 description = "LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows"
 readme = "README.md"

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/src/versionhq/__init__.py

@@ -18,7 +18,7 @@ from versionhq.tool.model import Tool
 from versionhq.tool.composio_tool import ComposioHandler
 
 
-__version__ = "1.1.10.2"
+__version__ = "1.1.10.3"
 __all__ = [
     "Agent",
     "Customer",

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/src/versionhq/agent/model.py

@@ -390,7 +390,7 @@ class Agent(BaseModel):
         return raw_response
 
 
-    def execute_task(self, task, context: Optional[str] = None, task_tools: Optional[List[Tool | ToolSet]] = None) -> str:
+    def execute_task(self, task, context: Optional[str] = None, task_tools: Optional[List[Tool | ToolSet]] = list()) -> str:
         """
         Execute the task and return the response in string.
         The agent utilizes the tools in task or their own tools if the task.can_use_agent_tools is True.
@@ -405,24 +405,6 @@ class Agent(BaseModel):
         if context is not task.prompt_context:
             task_prompt += context
 
-            # if agent_tools_to_run_without_llm:
-            #     tool_results = []
-            #     for item in agent_tools_to_run_without_llm:
-            #         if isinstance(item, ToolSet):
-            #             tool_result = item.tool.run(**item.kwargs)
-            #             tool_results.append(tool_result)
-            #         elif isinstance(item, Tool):
-            #             tool_result = item.run()
-            #             tool_results.append(tool_result)
-            #         else:
-            #             try:
-            #                 item.run()
-            #             except:
-            #                 pass
-
-            #     if task.tool_res_as_final is True:
-            #         return tool_results
-
         # if self.team and self.team._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)
         # else:

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/src/versionhq/llm/llm_vars.py

@@ -16,7 +16,7 @@ litellm.pick_cheapest_chat_models_from_llm_provider(custom_llm_provider: str, n=
 
 MODELS = {
     "openai": [
-        "gpt-3.5-turbo",
+        # "gpt-3.5-turbo",
         "gpt-4",
         "gpt-4o",
         "gpt-4o-mini",

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/src/versionhq/llm/model.py

@@ -196,6 +196,7 @@ class LLM(BaseModel):
         """
         Execute LLM based on the agent's params and model params.
         """
+        litellm.drop_params = True
 
         with suppress_warnings():
             if len(self.callbacks) > 0:
@@ -206,7 +207,7 @@ class LLM(BaseModel):
                     self.tools = [item.tool.properties if isinstance(item, ToolSet) else item.properties for item in tools]
 
                 if response_format:
-                    self.response_format = { "type": "json_object" } if self.model == "gpt-3.5-turbo" or tool_res_as_final else response_format
+                    self.response_format = { "type": "json_object" } if tool_res_as_final else response_format
 
                 provider = self.provider if self.provider else "openai"
 
@@ -227,6 +228,7 @@ class LLM(BaseModel):
                 res = litellm.completion(messages=messages, stream=False, **params)
 
                 if self.tools:
+                    messages.append(res["choices"][0]["message"])
                     tool_calls = res["choices"][0]["message"]["tool_calls"]
                     tool_res = ""
 
@@ -242,18 +244,24 @@ class LLM(BaseModel):
                                 tool_instance = tool.tool
                                 args = tool.kwargs
                                 res = tool_instance.run(params=args)
-                                tool_res += str(res)
+
+                                if tool_res_as_final:
+                                    tool_res += str(res)
+                                else:
+                                    messages.append({ "role": "tool", "tool_call_id": item.id, "content": str(res) })
 
                             elif (isinstance(tool, Tool) or type(tool) == Tool) and (tool.name.replace(" ", "_") == func_name or tool.func.__name__ == func_name):
                                 res = tool.run(params=func_args)
-                                tool_res += str(res)
+                                if tool_res_as_final:
+                                    tool_res += str(res)
+                                else:
+                                    messages.append({ "role": "tool", "tool_call_id": item.id, "content": str(res) })
 
-                    if tool_res_as_final == True:
+                    if tool_res_as_final:
                         return tool_res
-                        pass
 
                     else:
-                        messages.append({ "role": "tool", "tool_call_id": tool_calls.id, "content": tool_res })
+                        print(messages)
                         res = litellm.completion(messages=messages, stream=False, **params)
 
                 return res["choices"][0]["message"]["content"]

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/src/versionhq/task/model.py

@@ -4,10 +4,10 @@ import datetime
 import uuid
 from concurrent.futures import Future
 from hashlib import md5
-from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Type
+from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Type, TypeVar
 from typing_extensions import Annotated, Self
 
-from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf
+from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf, field_validator
 from pydantic_core import PydanticCustomError
 
 from versionhq._utils.process_config import process_config
@@ -96,8 +96,8 @@ class ResponseField(BaseModel):
                 for item in self.properties:
                     p.update(**item._format_props())
 
-                    if item.required:
-                        r.append(item.title)
+                    # if item.required:
+                    r.append(item.title)
 
             props = {
                 "type": schema_type,
@@ -161,14 +161,13 @@ class ResponseField(BaseModel):
 
 class TaskOutput(BaseModel):
     """
-    Store the final output of the task in TaskOutput class.
-    Depending on the task output format, use `raw`, `pydantic`, `json_dict` accordingly.
+    A class to store the final output of the given task in raw (string), json_dict, and pydantic class formats.
     """
 
     task_id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="store Task ID")
     raw: str = Field(default="", description="Raw output of the task")
     json_dict: Dict[str, Any] = Field(default=None, description="`raw` converted to dictionary")
-    pydantic: Optional[Any] = Field(default=None, description="`raw` converted to the abs. pydantic model")
+    pydantic: Optional[Any] = Field(default=None)
     tool_output: Optional[Any] = Field(default=None, description="store tool result when the task takes tool output as its final output")
 
     def __str__(self) -> str:
@@ -256,7 +255,7 @@ class Task(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def process_model_config(cls, values: Dict[str, Any]) -> None:
+    def process_config(cls, values: Dict[str, Any]) -> None:
         return process_config(values_to_update=values, model_class=cls)
 
 
@@ -276,16 +275,16 @@ class Task(BaseModel):
         return self
 
 
-    @model_validator(mode="after")
-    def set_attributes_based_on_config(self) -> Self:
-        """
-        Set attributes based on the task configuration.
-        """
+    # @model_validator(mode="after")
+    # def set_attributes_based_on_config(self) -> Self:
+    #     """
+    #     Set attributes based on the task configuration.
+    #     """
 
-        if self.config:
-            for key, value in self.config.items():
-                setattr(self, key, value)
-        return self
+    #     if self.config:
+    #         for key, value in self.config.items():
+    #             setattr(self, key, value)
+    #     return self
 
 
     @model_validator(mode="after")
@@ -322,7 +321,7 @@ class Task(BaseModel):
         if self.pydantic_custom_output:
             output_prompt = f"""
 Your response MUST STRICTLY follow the given repsonse format:
-JSON schema: {str({k: v for k, v in self.pydantic_custom_output.__fields__.items()})}
+JSON schema: {str(self.pydantic_custom_output)}
 """
 
         elif self.response_fields:
@@ -380,16 +379,13 @@ Ref. Output image: {output_formats_to_follow}
 
     def _structure_response_format(self, data_type: str = "object", model_provider: str = "gemini") -> Dict[str, Any] | None:
         """
-        Create and return a valid response format using
-            - mannual response schema from `self.response_fields`, or
-            - SDK objects from `pydantic_custom_output`.
-        OpenAI:
-        https://platform.openai.com/docs/guides/structured-outputs?context=ex1#function-calling-vs-response-format
-        https://platform.openai.com/docs/guides/structured-outputs?context=with_parse#some-type-specific-keywords-are-not-yet-supported
-        Gemini:
+        Structure a response format either from`response_fields` or `pydantic_custom_output`.
+        1 nested item is accepted.
         """
 
-        response_schema = None
+        from versionhq.task.structured_response import StructuredOutput
+
+        response_format: Dict[str, Any] = None
 
         if self.response_fields:
             properties, required_fields = {}, []
@@ -406,37 +402,19 @@ Ref. Output image: {output_formats_to_follow}
                 "type": "object",
                 "properties": properties,
                 "required": required_fields,
-                "additionalProperties": False, # for openai
+                "additionalProperties": False,
             }
 
-
-        elif self.pydantic_custom_output:
-            response_schema = {
-                **self.pydantic_custom_output.model_json_schema(),
-                "additionalProperties": False,
-                "required": [k for k, v in self.pydantic_custom_output.__fields__.items()],
-                "strict": True,
+            response_format = {
+                "type": "json_schema",
+                "json_schema": { "name": "outcome", "schema": response_schema }
             }
 
 
-        if response_schema:
-            if model_provider == "gemini":
-                return {
-                    "type": data_type,
-                    "response_schema": response_schema,
-                    "enforce_validation": True
-                }
+        elif self.pydantic_custom_output:
+            response_format = StructuredOutput(response_format=self.pydantic_custom_output)._format()
 
-            if model_provider == "openai":
-                if self.pydantic_custom_output:
-                    return self.pydantic_custom_output
-                else:
-                    return {
-                        "type": "json_schema",
-                        "json_schema": { "name": "outcome", "strict": True, "schema": response_schema },
-                    }
-        else:
-            return None
+        return response_format
 
 
     def _create_json_output(self, raw: str) -> Dict[str, Any]:
@@ -477,17 +455,16 @@ Ref. Output image: {output_formats_to_follow}
 
     def _create_pydantic_output(self, raw: str = None, json_dict: Dict[str, Any] = None) -> InstanceOf[BaseModel]:
         """
-        Create pydantic output from the `raw` result.
+        Create pydantic output from raw or json_dict output.
         """
 
-        output_pydantic = None
-        json_dict = json_dict
+        output_pydantic = self.pydantic_custom_output
 
         try:
-            if not json_dict:
-                json_dict = self._create_json_output(raw=raw)
+            json_dict = json_dict if json_dict else self._create_json_output(raw=raw)
 
-            output_pydantic = self.pydantic_custom_output(**json_dict)
+            for k, v in json_dict.items():
+                setattr(output_pydantic, k, v)
 
         except:
             pass
@@ -600,13 +577,14 @@ Ref. Output image: {output_formats_to_follow}
         if self.callback:
             self.callback({ **self.callback_kwargs, **self.output.__dict__ })
 
-        # if self.output_file:
+        # if self.output_file: ## disabled for now
         #     content = (
         #         json_output
         #         if json_output
         #         else pydantic_output.model_dump_json() if pydantic_output else result
         #     )
         #     self._save_file(content)
+
         ended_at = datetime.datetime.now()
         self.execution_span_in_sec = (ended_at - started_at).total_seconds()
 

versionhq-1.1.10.3/src/versionhq/task/structured_response.py

@@ -0,0 +1,142 @@
+#! FIXME
+from typing import Dict, Optional, Type, List, Any, TypeVar
+
+from pydantic import BaseModel, Field, InstanceOf
+
+from versionhq.llm.llm_vars import SchemaType
+from versionhq.llm.model import LLM
+
+
+"""
+Structure a response schema (json schema) from the given Pydantic model.
+"""
+
+
+class StructuredObject:
+    """
+    A class to store the structured dictionary.
+    """
+    provider: str = "openai"
+    field: Type[Field]
+
+    title: str
+    dtype: str = "object"
+    properties: Dict[str, Dict[str, str]] = dict()
+    required: List[str] = list()
+    additionalProperties: bool = False
+
+    def __init__(self, name, field: Type[Field], provider: str | InstanceOf[LLM] = "openai"):
+        self.title = name
+        self.field = field
+        self.dtype = "object"
+        self.additionalProperties = False
+        self.provider = provider if isinstance(provider, str) else provider.provider
+
+    def _format(self):
+        if not self.field:
+            pass
+        else:
+            description = self.field.description if hasattr(self.field, "description") and self.field.description is not None else ""
+            self.properties.update({"item": { "type": SchemaType(self.field.annotation.__args__).convert() }})
+            self.required.append("item")
+
+            return {
+                self.title: {
+                    "type": self.dtype,
+                    "description": description,
+                    "properties": self.properties,
+                    "additionalProperties": self.additionalProperties,
+                    "required": self.required
+                }
+            }
+
+
+
+class StructuredList:
+    """
+    A class to store a structured list with 1 nested object.
+    """
+    provider: str = "openai"
+    field: Type[Field]
+    title: str = ""
+    dtype: str = "array"
+    items: Dict[str, Dict[str, str]] = dict()
+
+    def __init__(self, name, field: Type[Field], provider: str | LLM = "openai"):
+        self.provider = provider if isinstance(provider, str) else provider.provider
+        self.field = field
+        self.title = name
+        self.dtype = "array"
+        self.items = dict()
+
+
+    def _format(self):
+        field = self.field
+        if not field:
+            pass
+        else:
+            description = "" if field.description is None else field.description
+            props = {}
+
+            for item in field.annotation.__args__:
+                nested_object_type = item.__origin__ if hasattr(item, "__origin__") else item
+
+                if nested_object_type == dict:
+                    props.update({
+                        "nest":  {
+                            "type": "object",
+                            "properties": { "item": { "type": "string"} }, #! REFINEME - field title <>`item`
+                            "required": ["item",],
+                            "additionalProperties": False
+                        }})
+
+                elif nested_object_type == list:
+                    props.update({
+                        "nest":  {
+                            "type": "array",
+                            "items": { "item": { "type": "string" } }, #! REFINEME - field title <>`item`
+                        }})
+                else:
+                    props.update({ "nest": { "type": SchemaType(nested_object_type).convert() }})
+
+            self.items = { **props }
+            return {
+                 self.title: {
+                    "type": self.dtype,
+                    "description": description,
+                    "items": self.items,
+                }
+            }
+
+
+
+
+class StructuredOutput(BaseModel):
+    response_format: Any = None
+    provider: str = "openai"
+    applicable_models: List[InstanceOf[LLM] | str] = list()
+    name: str = ""
+    schema: Dict[str, Any] = dict(type="object", additionalProperties=False, properties=dict(), required=list())
+
+
+    def _format(self, **kwargs):
+        if self.response_format is None:
+            pass
+
+        self.name = self.response_format.__name__
+
+        for name, field in self.response_format.model_fields.items():
+            self.schema["required"].append(name)
+
+            if hasattr(field.annotation, "__origin__") and field.annotation.__origin__ == dict:
+                self.schema["properties"].update(StructuredObject(name=name, field=field)._format())
+
+            elif hasattr(field.annotation, "__origin__") and field.annotation.__origin__ == list:
+                self.schema["properties"].update(StructuredList(name=name, field=field)._format())
+            else:
+                self.schema["properties"].update({ name: { "type": SchemaType(field.annotation).convert(), **kwargs }})
+
+        return {
+            "type": "json_schema",
+            "json_schema": { "name": self.name, "schema": self.schema }
+        }

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/src/versionhq.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.1.10.2
+Version: 1.1.10.3
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/src/versionhq.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ src/versionhq/task/__init__.py
 src/versionhq/task/formatter.py
 src/versionhq/task/log_handler.py
 src/versionhq/task/model.py
+src/versionhq/task/structured_response.py
 src/versionhq/team/__init__.py
 src/versionhq/team/model.py
 src/versionhq/team/team_planner.py

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/tests/agent/agent_test.py

@@ -1,4 +1,6 @@
 import os
+from unittest import mock
+from unittest.mock import patch
 import pytest
 from typing import Callable, Any
 
@@ -6,6 +8,7 @@ from versionhq.agent.model import Agent
 from versionhq.agent.TEMPLATES.Backstory import BACKSTORY_SHORT, BACKSTORY_FULL
 from versionhq.llm.model import LLM, DEFAULT_MODEL_NAME
 from versionhq.tool.model import Tool
+from versionhq.tool.decorator import tool
 
 MODEL_NAME = os.environ.get("DEFAULT_MODEL_NAME", "gpt-3.5-turbo")
 LITELLM_API_KEY = os.environ.get("LITELLM_API_KEY")
@@ -209,3 +212,29 @@ def test_agent_with_custom_tools():
     assert agent.tools[0] is tool
     assert agent.tools[0]._run(message="hi") == "hi_demo"
     assert agent.tools[0].name == "custom tool"
+
+
+# @pytest.mark.vcr(filter_headers=["authorization"])
+def test_agent_custom_max_iterations():
+    from versionhq.task.model import Task
+
+    @tool
+    def get_final_answer() -> int:
+        """Get the final answer but don't give it yet, just re-use this tool non-stop."""
+        return 42
+
+    agent = Agent(role="demo", goal="test goal", maxit=1, allow_delegation=False, tools=[get_final_answer])
+
+    with patch.object(
+        LLM, "call", wraps=LLM(model=DEFAULT_MODEL_NAME).call
+    ) as private_mock:
+        task = Task(
+            description="The final answer is 42. But don't give it yet, instead keep using the `get_final_answer` tool.",
+            can_use_agent_tools=True
+        )
+        agent.execute_task(task=task)
+        assert private_mock.call_count == 1
+
+
+if __name__ == "__main__":
+    test_agent_custom_max_iterations()

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/tests/llm/llm_test.py

@@ -64,4 +64,3 @@ def test_create_llm_from_provider():
 
 if __name__ == "__main__":
     test_create_llm_from_valid_name()
-    test_create_llm_from_provider

versionhq-1.1.10.3/tests/task/__init__.py

@@ -0,0 +1,53 @@
+from typing import Dict, Any
+
+from pydantic import BaseModel
+
+from versionhq.agent.model import Agent
+from versionhq.task.model import ResponseField
+from versionhq.llm.model import DEFAULT_MODEL_NAME, LLM
+
+
+class DemoChild(BaseModel):
+    """
+    A nested outcome class.
+    """
+    ch_1: str
+    ch_2: dict[str, str]
+
+
+class DemoOutcome(BaseModel):
+    """
+    A demo pydantic class to validate the outcome with various nested data types.
+    """
+    test0: int
+    test1: float
+    test2: str
+    test3: bool
+    test4: list[str]
+    test5: dict[str, Any]
+    test6: list[dict[str, Any]]
+    test8: list[list[str]]
+    # children: List[DemoChild]
+
+
+demo_response_fields = [
+    ResponseField(title="test0", data_type=int),
+    ResponseField(title="test1", data_type=str, required=True),
+    ResponseField(title="test2", data_type=list, items=str),
+    ResponseField(title="test3", data_type=list, items=dict, properties=[
+        ResponseField(title="nest1", data_type=str),
+        ResponseField(title="nest2", type=dict, properties=[ResponseField(title="test", data_type=str)])
+    ]),
+    ResponseField(title="test4", data_type=dict, properties=[ResponseField(title="ch", data_type=tuple)]),
+    ResponseField(title="test5", data_type=bool),
+    ResponseField(title="test6", data_type=list, items=Any, required=False),
+    # ResponseField(title="children", data_type=list, items=type(DemoChild)),
+]
+
+
+def create_base_agent(model: str | LLM | Dict[str, Any]) -> Agent:
+    agent = Agent(role="demo", goal="My amazing goals", llm=model, max_tokens=3000, maxit=1)
+    return agent
+
+
+base_agent = create_base_agent(model=DEFAULT_MODEL_NAME)

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/tests/task/task_test.py

@@ -8,93 +8,41 @@ from pydantic import BaseModel, Field, InstanceOf
 from versionhq.agent.model import Agent
 from versionhq.task.model import Task, ResponseField, TaskOutput, ConditionalTask
 from versionhq.tool.model import Tool, ToolSet
-from versionhq.llm.llm_vars import MODELS
-from versionhq.llm.model import DEFAULT_MODEL_NAME, LLM
+from tests.task import DemoOutcome, demo_response_fields, base_agent
 
 
-class DemoChild(BaseModel):
-    """
-    A nested outcome class.
-    """
-    ch_1: str
-    ch_2: dict[str, str]
-
-
-class DemoOutcome(BaseModel):
-    """
-    A demo pydantic class to validate the outcome with various nested data types.
-    """
-    test0: int
-    test1: float
-    test2: str
-    test3: bool
-    test4: list[str]
-    # test5: dict[str, Any]
-    # test6: list[dict[str, Any]]
-    test7: Optional[list[str]]
-
-    test8: list[list[str]]
-    # children: List[DemoChild]
-
-
-demo_nested_response_fields = [
-    ResponseField(title="test0", data_type=int),
-    ResponseField(title="test1", data_type=str, required=True),
-    ResponseField(title="test2", data_type=list, items=str),
-    ResponseField(title="test3", data_type=list, items=dict, properties=[
-        ResponseField(title="nest1", data_type=str),
-        ResponseField(title="nest2", type=dict, properties=[ResponseField(title="test", data_type=str)])
-    ]),
-    ResponseField(title="test4", data_type=dict, properties=[ResponseField(title="ch", data_type=tuple)]),
-    ResponseField(title="test5", data_type=bool),
-    ResponseField(title="test6", data_type=list, items=Any, required=False),
-    # ResponseField(title="children", data_type=list, items=type(DemoChild)),
-]
-
-
-def create_base_agent(model: str | LLM | Dict[str, Any]) -> Agent:
-    agent = Agent(role="demo", goal="My amazing goals", llm=model, max_tokens=3000)
-    return agent
-
-agent = create_base_agent(model=DEFAULT_MODEL_NAME)
-
 
 def test_sync_execute_task_with_pydantic_outcome():
     task = Task(
-        description="Output random values strictly following the given response foramt and prompt.",
+        description="Output random values strictly following the data type defined in the given response format.",
         pydantic_custom_output=DemoOutcome
     )
-    res = task.execute_sync(agent=agent)
+    res = task.execute_sync(agent=base_agent)
 
     assert isinstance(res, TaskOutput) and res.task_id is task.id
-    assert isinstance(res.raw, str)
-    assert isinstance(res.json_dict, dict)
-    assert res.pydantic == DemoOutcome(**res.json_dict)
-    assert [v and type(v) is type(getattr(res.pydantic, k)) for k, v in res.pydantic.dict().items()]
-    # assert [isinstance(item.ch_1, str) and isinstance(item.ch_2, dict) for item in res.pydantic.children]
+    assert isinstance(res.raw, str) and isinstance(res.json_dict, dict)
+    assert [hasattr(res.pydantic, k) and getattr(res.pydantic, k) == v for k, v in res.json_dict.items()]
 
 
 def test_sync_execute_task_with_json_dict():
     task = Task(
-        description="Output random values strictly following the given response foramt and prompt.",
-        response_fields=demo_nested_response_fields
+        description="Output random values strictly following the data type defined in the given response format.",
+        response_fields=demo_response_fields
     )
-    res = task.execute_sync(agent=agent)
+    res = task.execute_sync(agent=base_agent)
 
     assert isinstance(res, TaskOutput) and res.task_id is task.id
     assert res.raw and isinstance(res.raw, str)
     assert res.pydantic is None
     assert res.json_dict and isinstance(res.json_dict, dict)
     assert [v and type(v) == task.response_fields[i].data_type for i, (k, v) in enumerate(res.json_dict.items())]
-    # assert [isinstance(item, DemoChild) and isinstance(item.ch_1, str) and isinstance(item.ch_2, dict)
-    #         for item in res.json_dict["children"]]
 
 
 def test_async_execute_task():
     task = Task(description="Return string: 'test'")
 
     with patch.object(Agent, "execute_task", return_value="test") as execute:
-        execution = task.execute_async(agent=agent)
+        execution = task.execute_async(agent=base_agent)
         result = execution.result()
         assert result.raw == "test"
         execute.assert_called_once_with(task=task, context=None, task_tools=list())
@@ -118,7 +66,7 @@ def test_sync_execute_with_task_context():
         ],
         context=[sub_task,]
     )
-    res = main_task.execute_sync(agent=agent)
+    res = main_task.execute_sync(agent=base_agent)
 
     assert isinstance(res, TaskOutput)
     assert res.task_id is main_task.id
@@ -129,7 +77,7 @@ def test_sync_execute_with_task_context():
     assert res.pydantic is None
     assert sub_task.output is not None
     assert sub_task.output.json_dict is not None
-    assert "subtask_result" in main_task.prompt(model_provider=agent.llm.provider)
+    assert "subtask_result" in main_task.prompt(model_provider=base_agent.llm.provider)
 
 
 def test_sync_execute_task_with_prompt_context():
@@ -144,9 +92,7 @@ def test_sync_execute_task_with_prompt_context():
 
     sub_task = Task(
         description="return the output following the given prompt.",
-        response_fields=[
-            ResponseField(title="result", data_type=str, required=True),
-        ]
+        response_fields=[ResponseField(title="result", data_type=str, required=True),]
     )
     main_task = Task(
         description="return the output following the given prompt.",
@@ -157,20 +103,16 @@ def test_sync_execute_task_with_prompt_context():
         ],
         context=[sub_task]
     )
-    res = main_task.execute_sync(agent=agent, context="plan a Black Friday campaign.")
+    res = main_task.execute_sync(agent=base_agent, context="plan a Black Friday campaign.")
 
     assert isinstance(res, TaskOutput) and res.task_id is main_task.id
     assert res.raw and isinstance(res.raw, str)
     assert res.json_dict and isinstance(res.json_dict, dict)
-    assert res.pydantic == Outcome(test1=res.json_dict["test1"], test2=res.json_dict["test2"])
-
+    assert res.pydantic.test1 == res.json_dict["test1"] and res.pydantic.test2 == res.json_dict["test2"]
     assert sub_task.output is not None
-    assert sub_task.output.json_dict is not None
-    assert sub_task.output.pydantic is None
-
-    assert "result" in main_task.prompt(model_provider=agent.llm.provider)
+    assert "result" in main_task.prompt(model_provider=base_agent.llm.provider)
     assert main_task.prompt_context == "plan a Black Friday campaign."
-    assert "plan a Black Friday campaign." in main_task.prompt(model_provider=agent.llm.provider)
+    assert "plan a Black Friday campaign." in main_task.prompt(model_provider=base_agent.llm.provider)
 
 
 def test_callback():
@@ -193,7 +135,7 @@ def test_callback():
         callback=callback_func,
         callback_kwargs=dict(added_condition="demo for pytest")
     )
-    res = task.execute_sync(agent=agent)
+    res = task.execute_sync(agent=base_agent)
 
     assert res is not None
     assert isinstance(res, TaskOutput)
@@ -222,7 +164,7 @@ def test_conditional_task():
         description="erturn the output following the given prompt.",
         response_fields=[ResponseField(title="test1", data_type=str, required=True),],
     )
-    res = task.execute_sync(agent=agent)
+    res = task.execute_sync(agent=base_agent)
 
     conditional_task = ConditionalTask(
         description="return the output following the given prompt.",
@@ -271,7 +213,6 @@ def test_task_with_agent_tools():
     class CustomTool(Tool):
         name: str = "custom tool"
 
-    custom_tool = CustomTool(func=demo_func)
     custom_tool = CustomTool(func=demo_func)
     agent.tools = [custom_tool]
     res = task.execute_sync(agent=agent)
@@ -297,18 +238,18 @@ def test_task_with_tools():
 
     custom_tool = CustomTool(func=random_func)
     task.tools = [custom_tool]
-    res = task.execute_sync(agent=agent)
+    res = task.execute_sync(agent=base_agent)
     assert "_demo" in res.tool_output
 
     task.tools = [custom_tool]
-    res = task.execute_sync(agent=agent)
+    res = task.execute_sync(agent=base_agent)
     assert res.tool_output is not None
 
 
 
 def test_task_without_response_format():
     task = Task(description="return a simple output with any random values.")
-    res = task.execute_sync(agent=agent)
+    res = task.execute_sync(agent=base_agent)
 
     assert res and isinstance(res, TaskOutput)
     assert res.json_dict and isinstance(res.json_dict, dict)
@@ -332,10 +273,4 @@ def test_build_agent_without_developer_prompt():
 
 
 
-if __name__ == "__main__":
-    test_task_with_tools()
-
-
-# tool - use_llm = true -
-# task - agent - maxit
-# agents with multiple callbacks
+# task - maxit, loop, rpm

{versionhq-1.1.10.2 → versionhq-1.1.10.3}/tests/tool/tool_test.py

@@ -135,8 +135,3 @@ def test_cache_tool():
 
     assert my_tool.cache_handler.read(tool_name=my_tool.name, input=str({"x": 3})) == 5
     assert my_tool.cache_handler._cache[f"{my_tool.name}-{str({"x": 3})}"] == 5
-
-
-
-if __name__ =="__main__":
-    test_tool_handler_with_cache()