versionhq 1.1.9.14__py3-none-any.whl → 1.1.10.3__py3-none-any.whl

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/team/model.py

@@ -435,11 +435,8 @@ class Team(BaseModel):
             if not agent.function_calling_llm and self.function_calling_llm:
                 agent.function_calling_llm = self.function_calling_llm
 
-            # if agent.allow_code_execution:
-            #     agent.tools += agent.get_code_execution_tools()
-
-            if not agent.step_callback and self.step_callback:
-                agent.step_callback = self.step_callback
+            if self.step_callback:
+                agent.callbacks.append(self.step_callback)
 
         if self.process is None:
             self.process = TaskHandlingProcess.sequential

versionhq/team/team_planner.py

@@ -1,6 +1,6 @@
 import os
 from dotenv import load_dotenv
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Dict
 from pydantic import BaseModel, Field
 
 load_dotenv(override=True)
@@ -42,10 +42,9 @@ class TeamPlanner:
                     Based on the following task summary, draft a AI agent's role and goal in concise manner.
                     Task summary: {unassgined_task.summary}
                 """,
-                expected_output_json=True,
-                output_field_list=[
-                    ResponseField(title="goal", type=str, required=True),
-                    ResponseField(title="role", type=str, required=True),
+                response_fields=[
+                    ResponseField(title="goal", data_type=str, required=True),
+                    ResponseField(title="role", data_type=str, required=True),
                 ],
             )
             res = task.execute_sync(agent=agent_creator)
@@ -67,7 +66,7 @@ class TeamPlanner:
         """
 
         from versionhq.agent.model import Agent
-        from versionhq.task.model import Task, ResponseField
+        from versionhq.task.model import Task
 
         team_planner = Agent(
             role="team planner",
@@ -76,18 +75,18 @@ class TeamPlanner:
         )
 
         task_summary_list = [task.summary for task in self.tasks]
+
+        class TeamPlanIdea(BaseModel):
+            plan: str | Dict[str, Any] = Field(default=None, description="a decriptive plan to be executed by the team")
+
+
         task = Task(
             description=f"""
                 Based on the following task summaries, create the most descriptive plan that the team can execute most efficiently. Take all the task summaries - task's description and tools available - into consideration. Your answer only contains a dictionary.
 
                 Task summaries: {" ".join(task_summary_list)}
-             """,
-            expected_output_json=False,
-            expected_output_pydantic=True,
-            output_field_list=[
-                ResponseField(title="task", type=str, required=True)
-                for task in self.tasks
-            ],
+            """,
+            pydantic_custom_output=TeamPlanIdea
         )
         output = task.execute_sync(agent=team_planner, context=context, tools=tools)
         return output

versionhq/tool/__init__.py

@@ -1,56 +0,0 @@
-from enum import Enum
-
-DEFAULT_AUTH_SCHEME = "OAUTH2"
-
-class ComposioAuthScheme(str, Enum):
-    OAUTH2 = "OAUTH2"
-    BEARER_TOKEN = "BEARER_TOKEN"
-    API_KEY = "API_KEY"
-
-
-class ComposioAppName(str, Enum):
-    """
-    Enum to store app names that we can connect via Composio as data pipelines or destination services.
-    """
-
-    SALESFORCE = "salesforce"
-    AIRTABLE = "airtable"
-    MAILCHIMP = "mailchimp"
-    HUBSPOT = "hubspot"
-    KLAVIYO = "klaviyo"
-    GOOGLESHEET = "googlesheets"
-    GMAIL = "gmail"
-    FACEBOOK = "facebook"
-    TWITTER = "twitter"
-    TWITTER_MEDIA = "twitter_media"
-    LINKEDIN = "linkedin"
-
-
-composio_app_set = [
-    (ComposioAppName.SALESFORCE, ComposioAuthScheme.OAUTH2),
-    (ComposioAppName.AIRTABLE, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.API_KEY, ComposioAuthScheme.BEARER_TOKEN),
-    (ComposioAppName.MAILCHIMP, ComposioAuthScheme.OAUTH2),
-    (ComposioAppName.HUBSPOT, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.BEARER_TOKEN),
-    (ComposioAppName.KLAVIYO, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.API_KEY),
-    (ComposioAppName.GOOGLESHEET, ComposioAuthScheme.OAUTH2),
-    (ComposioAppName.GMAIL, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.BEARER_TOKEN),
-    (ComposioAppName.TWITTER, ComposioAuthScheme.OAUTH2),
-    (ComposioAppName.TWITTER_MEDIA, ComposioAuthScheme.OAUTH2),
-    (ComposioAppName.FACEBOOK, ComposioAuthScheme.OAUTH2),
-    (ComposioAppName.LINKEDIN, ComposioAuthScheme.OAUTH2),
-]
-
-class ComposioStatus(str, Enum):
-    INITIATED = "INITIATED"
-    ACTIVE = "ACTIVE"
-    FAILED = "FAILED"
-
-
-
-
-class ComposioAction(str, Enum):
-    """
-    Enum to store composio's action that can be called via `Actions.xxx`
-    """
-    # HUBSPOT_INITIATE_DATA_IMPORT_PROCESS = "hubspot_initate_date_import_process"
-    HUBSPOT_CREATE_PIPELINE_STAGE = "hubspot_create_pipeline_stage"

versionhq/tool/cache_handler.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, PrivateAttr, Field, InstanceOf
+
+
+class CacheHandler(BaseModel):
+    """
+    A class to add or read cache
+    """
+
+    _cache: Dict[str, Any] = PrivateAttr(default_factory=dict)
+
+    def add(self, tool_name: str, input: str, output: Any) -> None:
+        self._cache[f"{tool_name}-{input}"] = output
+
+    def read(self, tool_name: str, input: str) -> Optional[str]:
+        return self._cache.get(f"{tool_name}-{input}")
+
+
+
+class CacheTool(BaseModel):
+    """
+    A cache tool to read the cached result.
+    """
+
+    name: str = "Cache Tool"
+    cache_handler: InstanceOf[CacheHandler] = Field(default_factory=CacheHandler)
+
+    def read_cache(self, key):
+        split = key.split("tool:")
+        tool = split[1].split("|input:")[0].strip()
+        tool_input = split[1].split("|input:")[1].strip()
+        return self.cache_handler.read(tool, tool_input)
+
+    def tool(self):
+        return Tool(
+            func=self.read_cache,
+            name=self.name,
+            description="Read from cache"
+        )

versionhq/tool/composio_tool.py

@@ -11,9 +11,10 @@ from pydantic_core import PydanticCustomError
 from composio import ComposioToolSet
 from composio_langchain import action
 
-from versionhq.tool import ComposioAppName, ComposioAuthScheme, composio_app_set, ComposioStatus, ComposioAction
+from versionhq.tool.composio_tool_vars import ComposioAppName, ComposioAuthScheme, composio_app_set, ComposioStatus, ComposioAction
+from versionhq.tool.cache_handler import CacheHandler
 from versionhq._utils.logger import Logger
-from versionhq._utils.cache_handler import CacheHandler
+
 
 load_dotenv(override=True)
 

versionhq/tool/composio_tool_vars.py

@@ -0,0 +1,56 @@
+from enum import Enum
+
+DEFAULT_AUTH_SCHEME = "OAUTH2"
+
+class ComposioAuthScheme(str, Enum):
+    OAUTH2 = "OAUTH2"
+    BEARER_TOKEN = "BEARER_TOKEN"
+    API_KEY = "API_KEY"
+
+
+class ComposioAppName(str, Enum):
+    """
+    Enum to store app names that we can connect via Composio as data pipelines or destination services.
+    """
+
+    SALESFORCE = "salesforce"
+    AIRTABLE = "airtable"
+    MAILCHIMP = "mailchimp"
+    HUBSPOT = "hubspot"
+    KLAVIYO = "klaviyo"
+    GOOGLESHEET = "googlesheets"
+    GMAIL = "gmail"
+    FACEBOOK = "facebook"
+    TWITTER = "twitter"
+    TWITTER_MEDIA = "twitter_media"
+    LINKEDIN = "linkedin"
+
+
+composio_app_set = [
+    (ComposioAppName.SALESFORCE, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.AIRTABLE, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.API_KEY, ComposioAuthScheme.BEARER_TOKEN),
+    (ComposioAppName.MAILCHIMP, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.HUBSPOT, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.BEARER_TOKEN),
+    (ComposioAppName.KLAVIYO, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.API_KEY),
+    (ComposioAppName.GOOGLESHEET, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.GMAIL, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.BEARER_TOKEN),
+    (ComposioAppName.TWITTER, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.TWITTER_MEDIA, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.FACEBOOK, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.LINKEDIN, ComposioAuthScheme.OAUTH2),
+]
+
+class ComposioStatus(str, Enum):
+    INITIATED = "INITIATED"
+    ACTIVE = "ACTIVE"
+    FAILED = "FAILED"
+
+
+
+
+class ComposioAction(str, Enum):
+    """
+    Enum to store composio's action that can be called via `Actions.xxx`
+    """
+    # HUBSPOT_INITIATE_DATA_IMPORT_PROCESS = "hubspot_initate_date_import_process"
+    HUBSPOT_CREATE_PIPELINE_STAGE = "hubspot_create_pipeline_stage"

versionhq/tool/decorator.py

@@ -10,12 +10,11 @@ def tool(*args):
     """
 
     def create_tool(tool_name: str) -> Callable:
-
-        def _make_tool(f: Callable) -> Tool:
-            if f.__doc__ is None:
+        def _make_tool(func: Callable) -> Tool:
+            if func.__doc__ is None:
                 raise ValueError("Function must have a docstring")
 
-            if f.__annotations__ is None:
+            if func.__annotations__ is None:
                 raise ValueError("Function must have type annotations")
 
             class_name = "".join(tool_name.split()).title()
@@ -24,11 +23,11 @@ def tool(*args):
                 (BaseModel,),
                 {
                     "__annotations__": {
-                        k: v for k, v in f.__annotations__.items() if k != "return"
+                        k: v for k, v in func.__annotations__.items() if k != "return"
                     },
                 },
             )
-            return Tool(name=tool_name, function=f, args_schema=args_schema)
+            return Tool(name=tool_name, func=func, args_schema=args_schema)
 
         return _make_tool