versionhq 1.1.11.7__py3-none-any.whl → 1.1.12.1__py3-none-any.whl

versionhq/__init__.py

@@ -1,11 +1,8 @@
+# silence some warnings
 import warnings
-
-warnings.filterwarnings(
-    "ignore",
-    message="Pydantic serializer warnings:",
-    category=UserWarning,
-    module="pydantic.main",
-)
+warnings.filterwarnings(action="ignore", message="Pydantic serializer warnings:", category=UserWarning, module="pydantic.main")
+warnings.filterwarnings(action="ignore", category=UserWarning, module="pydantic._internal")
+warnings.filterwarnings(action="ignore", module="LiteLLM:utils")
 
 from versionhq.agent.model import Agent
 from versionhq.clients.customer.model import Customer
@@ -17,7 +14,7 @@ from versionhq.tool.model import Tool
 from versionhq.tool.composio_tool import ComposioHandler
 
 
-__version__ = "1.1.11.7"
+__version__ = "1.1.12.1"
 __all__ = [
     "Agent",
     "Customer",

versionhq/_utils/logger.py

@@ -36,10 +36,15 @@ class Printer:
 
 
 class Logger(BaseModel):
+    """
+    Control CLI messages.
+    Color: red = error, yellow = warning, blue = info (from vhq), green = info (from third party)
+    """
+
     verbose: bool = Field(default=True)
     _printer: Printer = PrivateAttr(default_factory=Printer)
 
     def log(self, level, message, color="yellow"):
         if self.verbose:
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            self._printer.print(f"\n{timestamp} - versionHQ - {level.upper()}: {message}", color=color)
+            self._printer.print(f"\n{timestamp} - versionHQ [{level.upper()}]: {message}", color=color)

versionhq/agent/inhouse_agents.py

@@ -0,0 +1,31 @@
+from versionhq.agent.model import Agent
+from versionhq.llm.model import DEFAULT_MODEL_NAME
+
+"""
+In-house agents to be called across the project.
+[Rules] agents' names and roles start with `vhq_`.
+"""
+
+vhq_client_manager = Agent(
+    role="vhq-Client Manager",
+    goal="Efficiently communicate with the client on the task progress",
+    llm=DEFAULT_MODEL_NAME
+)
+
+vhq_task_evaluator = Agent(
+    role="vhq-Task Evaluator",
+    goal="score the output according to the given evaluation criteria.",
+    llm=DEFAULT_MODEL_NAME,
+    llm_config=dict(top_p=0.8, top_k=30, max_tokens=5000, temperature=0.9),
+    maxit=1,
+    max_retry_limit=1
+)
+
+vhq_formation_planner = Agent(
+    role="vhq-Formation Planner",
+    goal="Plan a formation of agents based on the given task descirption.",
+    llm="gemini/gemini-2.0-flash-exp",
+    llm_config=dict(top_p=0.8, top_k=30, temperature=0.9),
+    maxit=1,
+    max_retry_limit=1
+)

versionhq/agent/model.py

@@ -6,10 +6,10 @@ from typing_extensions import Self
 from dotenv import load_dotenv
 import litellm
 
-from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator, ConfigDict
+from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator
 from pydantic_core import PydanticCustomError
 
-from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW_SIZE, DEFAULT_MODEL_NAME
+from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW_SIZE, DEFAULT_MODEL_NAME, PROVIDERS
 from versionhq.tool.model import Tool, ToolSet
 from versionhq.knowledge.model import BaseKnowledgeSource, Knowledge
 from versionhq.memory.contextual_memory import ContextualMemory
@@ -162,90 +162,47 @@ class Agent(BaseModel):
     @model_validator(mode="after")
     def set_up_llm(self) -> Self:
         """
-        Set up the base model and function calling model (if any) using the LLM class.
-        Pass the model config params: `llm`, `max_tokens`, `max_execution_time`, `callbacks`,`respect_context_window` to the LLM class.
-        The base model is selected on the client app, else use the default model.
+        Set up `llm` and `function_calling_llm` as valid LLM objects using the given values.
         """
-
         self.agent_ops_agent_name = self.role
+        self.llm = self._convert_to_llm_class(llm=self.llm)
 
-        if isinstance(self.llm, LLM):
-            llm = self._set_llm_params(self.llm)
-            self.llm = llm
-
-        elif isinstance(self.llm, str) or self.llm is None:
-            model_name = self.llm if self.llm is not None else DEFAULT_MODEL_NAME
-            llm = LLM(model=model_name)
-            updated_llm = self._set_llm_params(llm)
-            self.llm = updated_llm
-
-        else:
-            if isinstance(self.llm, dict):
-                model_name = self.llm.pop("model_name", self.llm.pop("deployment_name", str(self.llm)))
-                llm = LLM(model=model_name if model_name is not None else DEFAULT_MODEL_NAME)
-                updated_llm = self._set_llm_params(llm, { k: v for k, v in self.llm.items() if v is not None })
-                self.llm = updated_llm
-
-            else:
-                model_name = (getattr(self.llm, "model_name") or getattr(self.llm, "deployment_name") or str(self.llm))
-                llm = LLM(model=model_name)
-                llm_params = {
-                    "max_tokens": (getattr(self.llm, "max_tokens") or self.max_tokens or 3000),
-                    "timeout": getattr(self.llm, "timeout", self.max_execution_time),
-                    "callbacks": getattr(self.llm, "callbacks", None),
-                    "temperature": getattr(self.llm, "temperature", None),
-                    "logprobs": getattr(self.llm, "logprobs", None),
-                    "api_key": getattr(self.llm, "api_key", os.environ.get("LITELLM_API_KEY", None)),
-                    "base_url": getattr(self.llm, "base_url", None),
-                }
-                updated_llm = self._set_llm_params(llm, llm_params)
-                self.llm = updated_llm
-
-
-        """
-        Set up funcion_calling LLM as well.
-        Check if the model supports function calling, setup LLM instance accordingly, using the same params with the LLM.
-        """
-        if self.function_calling_llm:
-            if isinstance(self.function_calling_llm, LLM):
-                if self.function_calling_llm._supports_function_calling() == False:
-                    self.function_calling_llm = LLM(model=DEFAULT_MODEL_NAME)
-
-                updated_llm = self._set_llm_params(self.function_calling_llm)
-                self.function_calling_llm = updated_llm
+        function_calling_llm = self.function_calling_llm if self.function_calling_llm else self.llm if self.llm else None
+        function_calling_llm = self._convert_to_llm_class(llm=function_calling_llm)
+        if function_calling_llm._supports_function_calling():
+            self.function_calling_llm = function_calling_llm
+        return self
 
-            elif isinstance(self.function_calling_llm, str):
-                llm = LLM(model=self.function_calling_llm)
 
-                if llm._supports_function_calling() == False:
-                    llm = LLM(model=DEFAULT_MODEL_NAME)
+    def _convert_to_llm_class(self, llm: Any | None) -> LLM:
+        llm = llm if llm is not None else DEFAULT_MODEL_NAME
 
-                updated_llm = self._set_llm_params(llm)
-                self.function_calling_llm = updated_llm
+        match llm:
+            case LLM():
+                return self._set_llm_params(llm=llm)
 
-            else:
-                if isinstance(self.function_calling_llm, dict):
-                    model_name = self.function_calling_llm.pop("model_name", self.function_calling_llm.pop("deployment_name", str(self.function_calling_llm)))
-                    llm = LLM(model=model_name)
-                    updated_llm = self._set_llm_params(llm, { k: v for k, v in self.function_calling_llm.items() if v is not None })
-                    self.function_calling_llm = updated_llm
+            case str():
+                llm_obj = LLM(model=llm)
+                return self._set_llm_params(llm=llm_obj)
 
-                else:
-                    model_name = (getattr(self.function_calling_llm, "model_name") or getattr(self.function_calling_llm, "deployment_name") or str(self.function_calling_llm))
-                    llm = LLM(model=model_name)
-                    llm_params = {
-                        "max_tokens": (getattr(self.function_calling_llm, "max_tokens") or self.max_tokens or 3000),
-                        "timeout": getattr(self.function_calling_llm, "timeout", self.max_execution_time),
-                        "callbacks": getattr(self.function_calling_llm, "callbacks", None),
-                        "temperature": getattr(self.function_calling_llm, "temperature", None),
-                        "logprobs": getattr(self.function_calling_llm, "logprobs", None),
-                        "api_key": getattr(self.function_calling_llm, "api_key", os.environ.get("LITELLM_API_KEY", None)),
-                        "base_url": getattr(self.function_calling_llm, "base_url", None),
-                    }
-                    updated_llm = self._set_llm_params(llm, llm_params)
-                    self.function_calling_llm = updated_llm
+            case dict():
+                model_name = llm.pop("model_name", llm.pop("deployment_name", str(llm)))
+                llm_obj = LLM(model=model_name if model_name else DEFAULT_MODEL_NAME)
+                return self._set_llm_params(llm_obj, { k: v for k, v in llm.items() if v is not None })
 
-        return self
+            case _:
+                model_name = (getattr(self.llm, "model_name") or getattr(self.llm, "deployment_name") or str(self.llm))
+                llm_obj = LLM(model=model_name)
+                llm_params = {
+                    "max_tokens": (getattr(llm, "max_tokens") or self.max_tokens or 3000),
+                    "timeout": getattr(llm, "timeout", self.max_execution_time),
+                    "callbacks": getattr(llm, "callbacks", None),
+                    "temperature": getattr(llm, "temperature", None),
+                    "logprobs": getattr(llm, "logprobs", None),
+                    "api_key": getattr(llm, "api_key", os.environ.get("LITELLM_API_KEY", None)),
+                    "base_url": getattr(llm, "base_url", None),
+                }
+                return self._set_llm_params(llm=llm_obj, config=llm_params)
 
 
     def _set_llm_params(self, llm: LLM, config: Dict[str, Any] = None) -> LLM:
@@ -257,6 +214,11 @@ class Agent(BaseModel):
         llm.timeout = self.max_execution_time if llm.timeout is None else llm.timeout
         llm.max_tokens = self.max_tokens if self.max_tokens else llm.max_tokens
 
+        if llm.provider is None:
+            provider_name = llm.model.split("/")[0]
+            valid_provider = provider_name if provider_name in PROVIDERS else None
+            llm.provider = valid_provider
+
         if self.callbacks:
             llm.callbacks = self.callbacks
             llm._set_callbacks(llm.callbacks)
@@ -454,7 +416,7 @@ class Agent(BaseModel):
                 task.tokens = self.llm._tokens
 
             task_execution_counter += 1
-            self._logger.log(level="info", message=f"Agent response: {raw_response}", color="blue")
+            self._logger.log(level="info", message=f"Agent response: {raw_response}", color="green")
             return raw_response
 
         except Exception as e:
@@ -470,7 +432,7 @@ class Agent(BaseModel):
                     iterations += 1
 
                 task_execution_counter += 1
-                self._logger.log(level="info", message=f"Agent #{task_execution_counter} response: {raw_response}", color="blue")
+                self._logger.log(level="info", message=f"Agent #{task_execution_counter} response: {raw_response}", color="green")
                 return raw_response
 
             if not raw_response:
@@ -515,6 +477,7 @@ class Agent(BaseModel):
                 task_prompt += memory.strip()
 
 
+        ## comment out for now
         # if self.team and self.team._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)
         # else:

versionhq/knowledge/source_docling.py

@@ -12,17 +12,11 @@ try:
 except ImportError:
     import envoy
     envoy.run("uv add docling --optional docling")
-
-    from docling.datamodel.base_models import InputFormat
-    from docling.document_converter import DocumentConverter
-    from docling.exceptions import ConversionError
-    from docling_core.transforms.chunker.hierarchical_chunker import HierarchicalChunker
-    from docling_core.types.doc.document import DoclingDocument
     DOCLING_AVAILABLE = True
 except:
     DOCLING_AVAILABLE = False
 
-from pydantic import Field, InstanceOf
+from pydantic import Field
 
 from versionhq.knowledge.source import BaseKnowledgeSource
 from versionhq.storage.utils import fetch_db_storage_path
@@ -52,11 +46,20 @@ class DoclingSource(BaseKnowledgeSource):
     ))
 
     def __init__(self, *args, **kwargs):
-        if not DOCLING_AVAILABLE:
-            raise ImportError("The docling package is required. Please install the package using: $ uv add docling.")
-        else:
+        if DOCLING_AVAILABLE:
+            from docling.datamodel.base_models import InputFormat
+            from docling.document_converter import DocumentConverter
+            from docling.exceptions import ConversionError
+            from docling_core.transforms.chunker.hierarchical_chunker import HierarchicalChunker
+            from docling_core.types.doc.document import DoclingDocument
+
             super().__init__(*args, **kwargs)
 
+        else:
+            raise ImportError("The docling package is required. Please install the package using: $ uv add docling.")
+        # else:
+        #     super().__init__(*args, **kwargs)
+
 
     def _convert_source_to_docling_documents(self) -> List["DoclingDocument"]:
         conv_results_iter = self.document_converter.convert_all(self.valid_file_paths)

versionhq/llm/llm_vars.py

@@ -6,17 +6,21 @@ JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_
 PROVIDERS = [
     "openai",
     "gemini",
-    "sagemaker",
-
+    "openrouter",
+    "huggingface",
     "anthropic",
+    "sagemaker",
+    "bedrock",
     "ollama",
     "watson",
-    "bedrock",
     "azure",
     "cerebras",
     "llama",
 ]
 
+ENDPOINT_PROVIDERS = [
+    "huggingface",
+]
 
 """
 List of models available on the framework.
@@ -44,10 +48,17 @@ MODELS = {
     "anthropic": [
         "claude-3-5-sonnet-20241022",
         "claude-3-5-sonnet-20240620",
-        "claude-3-sonnet-20240229",
+        "claude-3-haiku-2024030",
         "claude-3-opus-20240229",
         "claude-3-haiku-20240307",
     ],
+    "openrouter": [
+        "openrouter/deepseek/deepseek-r1:free",
+        "openrouter/qwen/qwen-2.5-72b-instruct",
+    ],
+    "huggingface": [
+        "huggingface/qwen/qwen2.5-VL-72B-Instruct",
+    ],
     # "sagemaker": [
     #     "sagemaker/huggingface-text2text-flan-t5-base",
     #     "sagemaker/huggingface-llm-gemma-7b",
@@ -61,13 +72,7 @@ MODELS = {
       "ollama/llama3.1",
       "ollama/mixtral",
       "ollama/mixtral-8x22B-Instruct-v0.1",
-
-    ],
-    "deepseek": [
-        "deepseek/deepseek-reasoner",
-
     ],
-
     # "watson": [
     #     "watsonx/meta-llama/llama-3-1-70b-instruct",
     #     "watsonx/meta-llama/llama-3-1-8b-instruct",
@@ -83,7 +88,6 @@ MODELS = {
         "bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
         "bedrock/anthropic.claude-3-haiku-20240307-v1:0",
         "bedrock/anthropic.claude-3-opus-20240229-v1:0",
-        # "bedrock/anthropic.claude-v2:1",
         "bedrock/anthropic.claude-v2",
         "bedrock/anthropic.claude-instant-v1",
         "bedrock/meta.llama3-1-405b-instruct-v1:0",
@@ -109,24 +113,17 @@ MODELS = {
 KEYS = {
     "openai": ["OPENAI_API_KEY"],
     "gemini": ["GEMINI_API_KEY"],
-    "sagemaker": ["AWS_ACCESS_KEY_ID", "ADW_SECURET_ACCESS_KEY", "AWS_REGION_NAME"],
     "anthropic": ["ANTHROPIC_API_KEY"],
+    "huggingface": ["HUGGINGFACE_API_KEY", ],
+    "sagemaker": ["AWS_ACCESS_KEY_ID", "ADW_SECURET_ACCESS_KEY", "AWS_REGION_NAME"],
 }
 
 
-"""
-Use base_url to specify
-"""
-BASE_URLS = {
-    "deepseek": "https://api.deepseek.com"
-}
-
 
 """
 Max input token size by the model.
 """
 LLM_CONTEXT_WINDOW_SIZES = {
-    "gpt-3.5-turbo": 8192,
     "gpt-4": 8192,
     "gpt-4o": 128000,
     "gpt-4o-mini": 128000,
@@ -145,6 +142,7 @@ LLM_CONTEXT_WINDOW_SIZES = {
     "claude-3-sonnet-20240229": 200000,
     "claude-3-opus-20240229": 200000,
     "claude-3-haiku-20240307": 200000,
+    "claude-3-5-sonnet-2024102": 200000,
 
     "deepseek-chat": 128000,
     "deepseek/deepseek-reasoner": 8192,
@@ -162,111 +160,18 @@ LLM_CONTEXT_WINDOW_SIZES = {
     "llama3-70b-8192": 8192,
     "llama3-8b-8192": 8192,
     "mixtral-8x7b-32768": 32768,
-    "claude-3-5-sonnet-2024102": 200000,
-}
-
-
-
-
-LLM_BASE_URL_KEY_NAMES = {
-    "openai":  "OPENAI_API_BASE",
-     "gemini": "GEMINI_API_BASE",
-    "anthropic": "ANTHROPIC_API_BASE",
-}
-
-LLM_VARS = {
-    "openai": [
-        {
-            "prompt": "Enter your OPENAI API key (press Enter to skip)",
-            "key_name": "OPENAI_API_KEY",
-        }
-    ],
-    "anthropic": [
-        {
-            "prompt": "Enter your ANTHROPIC API key (press Enter to skip)",
-            "key_name": "ANTHROPIC_API_KEY",
-        }
-    ],
-    "gemini": [
-        {
-            "prompt": "Enter your GEMINI API key (press Enter to skip)",
-            "key_name": "GEMINI_API_KEY",
-        }
-    ],
-    "watson": [
-        {
-            "prompt": "Enter your WATSONX URL (press Enter to skip)",
-            "key_name": "WATSONX_URL",
-        },
-        {
-            "prompt": "Enter your WATSONX API Key (press Enter to skip)",
-            "key_name": "WATSONX_APIKEY",
-        },
-        {
-            "prompt": "Enter your WATSONX Project Id (press Enter to skip)",
-            "key_name": "WATSONX_PROJECT_ID",
-        },
-    ],
-    "ollama": [
-        {
-            "default": True,
-            "API_BASE": "http://localhost:11434",
-        }
-    ],
-    "bedrock": [
-        {
-            "prompt": "Enter your AWS Access Key ID (press Enter to skip)",
-            "key_name": "AWS_ACCESS_KEY_ID",
-        },
-        {
-            "prompt": "Enter your AWS Secret Access Key (press Enter to skip)",
-            "key_name": "AWS_SECRET_ACCESS_KEY",
-        },
-        {
-            "prompt": "Enter your AWS Region Name (press Enter to skip)",
-            "key_name": "AWS_REGION_NAME",
-        },
-    ],
-    "azure": [
-        {
-            "prompt": "Enter your Azure deployment name (must start with 'azure/')",
-            "key_name": "model",
-        },
-        {
-            "prompt": "Enter your AZURE API key (press Enter to skip)",
-            "key_name": "AZURE_API_KEY",
-        },
-        {
-            "prompt": "Enter your AZURE API base URL (press Enter to skip)",
-            "key_name": "AZURE_API_BASE",
-        },
-        {
-            "prompt": "Enter your AZURE API version (press Enter to skip)",
-            "key_name": "AZURE_API_VERSION",
-        },
-    ],
-    "cerebras": [
-        {
-            "prompt": "Enter your Cerebras model name (must start with 'cerebras/')",
-            "key_name": "model",
-        },
-        {
-            "prompt": "Enter your Cerebras API version (press Enter to skip)",
-            "key_name": "CEREBRAS_API_KEY",
-        },
-    ],
 }
 
 
 
 """
-Params for litellm.completion() func. Address common/unique params to each provider.
+Params for litellm.completion().
 """
 
 PARAMS = {
     "litellm": [
         "api_base",
-        "api_version,"
+        "api_version,",
         "num_retries",
         "context_window_fallback_dict",
         "fallbacks",

versionhq/llm/model.py

@@ -1,4 +1,3 @@
-import logging
 import json
 import os
 import sys
@@ -6,14 +5,13 @@ import threading
 import warnings
 from dotenv import load_dotenv
 import litellm
-from litellm import get_supported_openai_params, JSONSchemaValidationError
+from litellm import JSONSchemaValidationError
 from contextlib import contextmanager
 from typing import Any, Dict, List, Optional
 from typing_extensions import Self
-from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf, ConfigDict
-from pydantic_core import PydanticCustomError
+from pydantic import BaseModel, Field, PrivateAttr, model_validator, ConfigDict
 
-from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES, MODELS, PARAMS
+from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES, MODELS, PARAMS, PROVIDERS, ENDPOINT_PROVIDERS
 from versionhq.tool.model import Tool, ToolSet
 from versionhq._utils.logger import Logger
 
@@ -22,11 +20,8 @@ load_dotenv(override=True)
 LITELLM_API_KEY = os.environ.get("LITELLM_API_KEY")
 LITELLM_API_BASE = os.environ.get("LITELLM_API_BASE")
 DEFAULT_CONTEXT_WINDOW_SIZE = int(8192 * 0.75)
-DEFAULT_MODEL_NAME = os.environ.get("DEFAULT_MODEL_NAME")
-
-# proxy_openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"), organization="versionhq", base_url=LITELLM_API_BASE)
-# openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
-
+DEFAULT_MODEL_NAME = os.environ.get("DEFAULT_MODEL_NAME", "gpt-4o-mini")
+DEFAULT_MODEL_PROVIDER_NAME = os.environ.get("DEFAULT_MODEL_PROVIDER_NAME", "openai")
 
 class FilteredStream:
     def __init__(self, original_stream):
@@ -52,7 +47,8 @@ class FilteredStream:
 @contextmanager
 def suppress_warnings():
     with warnings.catch_warnings():
-        warnings.filterwarnings("ignore")
+        litellm.set_verbose = False
+        warnings.filterwarnings(action="ignore")
         old_stdout = sys.stdout
         old_stderr = sys.stderr
         sys.stdout = FilteredStream(old_stdout)
@@ -67,10 +63,7 @@ def suppress_warnings():
 
 class LLM(BaseModel):
     """
-    An LLM class to store params except for response formats which will be given in the task handling process.
-    Use LiteLLM to connect with the model of choice.
-    Some optional params are passed by the agent, else follow the default settings of the model provider.
-    Ref. https://docs.litellm.ai/docs/completion/input
+    An LLM class to store params to send to the LLM. Use LiteLLM or custom providers for the endpoint.
     """
 
     _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
@@ -78,17 +71,18 @@ class LLM(BaseModel):
     _tokens: int = PrivateAttr(default=0) # accumulate total tokens used for the call
     model_config = ConfigDict(extra="allow")
 
-    model: str = Field(default=DEFAULT_MODEL_NAME)
-    provider: Optional[str] = Field(default=None, description="model provider or custom model provider")
-    base_url: Optional[str] = Field(default=None, description="api base of the model provider")
-    api_key: Optional[str] = Field(default=None, description="api key of the model provider")
+    model: str = Field(default=None)
+    provider: Optional[str] = Field(default=None, description="model provider")
+    endpoint_provider: Optional[str] = Field(default=None, description="custom endpoint provider for pass through llm call. must need base_url")
+    base_url: Optional[str] = Field(default=None, description="api base url for endpoint provider")
+    api_key: Optional[str] = Field(default=None, description="api key to access the model")
 
     # optional params
+    response_format: Optional[Any] = Field(default=None)
     timeout: Optional[float | int] = Field(default=None)
     max_tokens: Optional[int] = Field(default=None)
     max_completion_tokens: Optional[int] = Field(default=None)
     context_window_size: Optional[int] = Field(default=DEFAULT_CONTEXT_WINDOW_SIZE)
-    callbacks: List[Any] = Field(default_factory=list)
     temperature: Optional[float] = Field(default=None)
     top_p: Optional[float] = Field(default=None)
     n: Optional[int] = Field(default=None)
@@ -99,8 +93,8 @@ class LLM(BaseModel):
     seed: Optional[int] = Field(default=None)
     logprobs: Optional[bool] = Field(default=None)
     top_logprobs: Optional[int] = Field(default=None)
-    response_format: Optional[Any] = Field(default=None)
     tools: Optional[List[Dict[str, Any]]] = Field(default_factory=list, description="store a list of tool properties")
+    callbacks: List[Any] = Field(default_factory=list)
 
     # LiteLLM specific fields
     api_base: Optional[str] = Field(default=None, description="litellm specific field - api base of the model provider")
@@ -114,54 +108,89 @@ class LLM(BaseModel):
     litellm.set_verbose = True
     os.environ['LITELLM_LOG'] = 'DEBUG'
 
+
     @model_validator(mode="after")
-    def validate_base_params(self) -> Self:
+    def validate_model_providers(self) -> Self:
         """
-        1) Set up a valid model name with the provider name using the MODEL list.
-        * Assign a default model and provider based on the given information when no model key is found in the MODEL list.
-
-        2) Set up other base parameters for the model and LiteLLM.
+        Validate the given model, provider, interface provider.
         """
 
-        if self.model is None:
-            self._logger.log(level="error", message="Model name is missing.", color="red")
-            raise PydanticCustomError("model_missing", "The model name must be provided.", {})
+        self._init_model_name = self.model
 
+        if self.model is None and self.provider is None:
+            self.model = DEFAULT_MODEL_NAME
+            self.provider = DEFAULT_MODEL_PROVIDER_NAME
 
-        self._init_model_name = self.model
-        self.model = None
-        self._tokens = 0
+        elif self.model is None and self.provider:
+            if self.provider not in PROVIDERS:
+                self._logger.log(level="warning", message=f"Invalid model provider is provided. We will assign a default model.", color="yellow")
+                self.model = DEFAULT_MODEL_NAME
+                self.provider = DEFAULT_MODEL_PROVIDER_NAME
 
-        if self.provider and MODELS.get(self.provider):
-            provider_model_list = MODELS.get(self.provider)
-            for item in provider_model_list:
-                if self.model is None:
-                    if item == self._init_model_name:
-                        self.model = item
-                    elif self._init_model_name in item and self.model is None:
-                        self.model = item
-                    else:
-                        temp_model = provider_model_list[0]
-                        self._logger.log(level="warning", message=f"The provided model: {self._init_model_name} is not in the list. We'll assign a model: {temp_model} from the selected model provider: {self.provider}.", color="yellow")
-                        self.model = temp_model
+            else:
+                provider_model_list = MODELS.get(self.provider)
+                if provider_model_list:
+                    self.model = provider_model_list[0]
+                    self.provider = self.provider
+                else:
+                    self._logger.log(level="warning", message=f"This provider has not models to be called. We will assign a default model.", color="yellow")
+                    self.model = DEFAULT_MODEL_NAME
+                    self.provider = DEFAULT_MODEL_PROVIDER_NAME
+
+        elif self.model and self.provider is None:
+            model_match = [
+                item for item in [
+                    [val for val in v if val == self.model][0] for k, v in MODELS.items() if [val for val in v if val == self.model]
+                ] if item
+            ]
+            model_partial_match = [
+                item for item in [
+                    [val for val in v if val.find(self.model) != -1][0] for k, v in MODELS.items() if [val for val in v if val.find(self.model) != -1]
+                ] if item
+            ]
+            provider_match = [k for k, v in MODELS.items() if k == self.model]
+
+            if model_match:
+                self.model = model_match[0]
+                self.provider = [k for k, v in MODELS.items() if self.model in v][0]
+
+            elif model_partial_match:
+                self.model = model_partial_match[0]
+                self.provider = [k for k, v in MODELS.items() if [item for item in v if item.find(self.model) != -1]][0]
+
+            elif provider_match:
+                provider = provider_match[0]
+                if self.MODELS.get(provider):
+                    self.provider = provider
+                    self.model = self.MODELS.get(provider)[0]
+                else:
+                    self.provider = DEFAULT_MODEL_PROVIDER_NAME
+                    self.model = DEFAULT_MODEL_NAME
+
+            else:
+                self.model = DEFAULT_MODEL_NAME
+                self.provider = DEFAULT_MODEL_PROVIDER_NAME
 
         else:
-            for k, v in MODELS.items():
-                for item in v:
-                    if self.model is None:
-                        if self._init_model_name == item:
-                            self.model = item
-                            self.provider = k
-
-                        elif self.model is None and self._init_model_name in item:
-                            self.model = item
-                            self.provider = k
-
-            if self.model is None:
-                self._logger.log(level="warning", message=f"The provided model \'{self.model}\' is not in the list. We'll assign a default model.", color="yellow")
+            provider_model_list = MODELS.get(self.provider)
+            if self.model not in provider_model_list:
+                self._logger.log(level="warning", message=f"The provided model: {self._init_model_name} is not in the list. We will assign a default model.", color="yellow")
                 self.model = DEFAULT_MODEL_NAME
-                self.provider = "openai"
+                self.provider = DEFAULT_MODEL_PROVIDER_NAME
 
+        # trigger pass-through custom endpoint.
+        if self.provider in ENDPOINT_PROVIDERS:
+            self.endpoint_provider = self.provider
+
+        return self
+
+
+    @model_validator(mode="after")
+    def validate_model_params(self) -> Self:
+        """
+        Set up valid params to the model after setting up a valid model, provider, interface provider names.
+        """
+        self._tokens = 0
 
         if self.callbacks:
             self._set_callbacks(self.callbacks)
@@ -173,7 +202,8 @@ class LLM(BaseModel):
             self.api_key = os.environ.get(api_key_name, None)
 
 
-        base_url_key_name = self.provider.upper() + "_API_BASE" if self.provider else None
+        base_url_key_name = self.endpoint_provider.upper() + "_API_BASE" if self.endpoint_provider else None
+
         if base_url_key_name:
             self.base_url = os.environ.get(base_url_key_name)
             self.api_base = self.base_url
@@ -181,22 +211,28 @@ class LLM(BaseModel):
         return self
 
 
-    def _create_valid_params(self, config: Dict[str, Any], provider: str = None) -> Dict[str, Any]:
-        params = dict()
-        valid_keys = list()
+    def _create_valid_params(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Return valid params (model + litellm original params) from the given config dict.
+        """
 
-        if not provider:
-            valid_keys = PARAMS.get("litellm") + PARAMS.get("common") + PARAMS.get(self.provider) if self.provider else PARAMS.get("litellm") + PARAMS.get("common")
-        else:
-            valid_keys = PARAMS.get("common") + PARAMS.get(self.provider)
+        valid_params, valid_keys = dict(), list()
+
+        if self.model:
+            valid_keys = litellm.get_supported_openai_params(model=self.model, custom_llm_provider=self.endpoint_provider, request_type="chat_completion")
+
+        if not valid_keys:
+            valid_keys = PARAMS.get("common")
+
+        valid_keys += PARAMS.get("litellm")
 
         for item in valid_keys:
             if hasattr(self, item) and getattr(self, item):
-                params[item] = getattr(self, item)
-            elif item in config:
-                params[item] = config[item]
+                valid_params[item] = getattr(self, item)
+            elif item in config and config[item]:
+                valid_params[item] = config[item]
 
-        return params
+        return valid_params
 
 
     def call(
@@ -218,21 +254,18 @@ class LLM(BaseModel):
                 self._set_callbacks(self.callbacks) # passed by agent
 
             try:
-                provider = self.provider if self.provider else "openai"
                 self.response_format = { "type": "json_object" } if tool_res_as_final == True else response_format
 
                 if not tools:
                     params = self._create_valid_params(config=config)
-                    res = litellm.completion(messages=messages, stream=False, **params)
+                    res = litellm.completion(model=self.model, messages=messages, stream=False, **params)
                     self._tokens += int(res["usage"]["total_tokens"])
                     return res["choices"][0]["message"]["content"]
 
                 else:
                     self.tools = [item.tool.properties if isinstance(item, ToolSet) else item.properties for item in tools]
-
-                    # if provider == "openai":
-                    params = self._create_valid_params(config=config, provider=provider)
-                    res = litellm.completion(messages=messages, model=self.model, tools=self.tools)
+                    params = self._create_valid_params(config=config)
+                    res = litellm.completion(model=self.model, messages=messages, **params)
                     tool_calls = res.choices[0].message.tool_calls
                     tool_res = ""
 
@@ -272,7 +305,7 @@ class LLM(BaseModel):
                     if tool_res_as_final:
                         return tool_res
                     else:
-                        res = litellm.completione(messages=messages, model=self.model, tools=self.tools)
+                        res = litellm.completion(model=self.model, messages=messages, **params)
                         self._tokens += int(res["usage"]["total_tokens"])
                         return res.choices[0].message.content
 
@@ -288,20 +321,17 @@ class LLM(BaseModel):
 
     def _supports_function_calling(self) -> bool:
         try:
-            params = get_supported_openai_params(model=self.model)
-            return "response_format" in params
+            if self.model:
+                params = litellm.get_supported_openai_params(model=self.model)
+                return "response_format" in params if params else False
         except Exception as e:
-            self._logger.log(level="error", message=f"Failed to get supported params: {str(e)}", color="red")
+            self._logger.log(level="warning", message=f"Failed to get supported params: {str(e)}", color="yellow")
             return False
 
 
     def _supports_stop_words(self) -> bool:
-        try:
-            params = get_supported_openai_params(model=self.model)
-            return "stop" in params
-        except Exception as e:
-            self._logger.log(level="error", message=f"Failed to get supported params: {str(e)}", color="red")
-            return False
+        supported_params = litellm.get_supported_openai_params(model=self.model, custom_llm_provider=self.endpoint_provider)
+        return "stop" in supported_params if supported_params else False
 
 
     def _get_context_window_size(self) -> int:

versionhq/task/evaluate.py

@@ -1,15 +1,13 @@
 from typing import List, Optional, Dict, Any
 from typing_extensions import Self
 
-from pydantic import BaseModel, Field, InstanceOf, model_validator
+from pydantic import BaseModel, Field, model_validator
 
 """
 Evaluate task output from accuracy, token consumption, latency perspectives, and mark the score from 0 to 1.
 """
 
 
-
-
 class ScoreFormat:
     def __init__(self, rate: float | int = 0, weight: int = 1):
         self.rate = rate
@@ -72,16 +70,16 @@ class EvaluationItem(BaseModel):
 
 
 class Evaluation(BaseModel):
-    # expected_outcome: Optional[str] = Field(default=None, description="human input on expected outcome")
     items: List[EvaluationItem] = []
     latency: int = Field(default=None, description="seconds")
     tokens: int = Field(default=None, description="tokens consumed")
     responsible_agent: Any = Field(default=None, description="store agent instance that evaluates the outcome")
 
+
     @model_validator(mode="after")
     def set_up_responsible_agent(self) -> Self:
-        from versionhq.agent.default_agents import task_evaluator
-        self.responsible_agent = task_evaluator
+        from versionhq.agent.inhouse_agents import vhq_task_evaluator
+        self.responsible_agent = vhq_task_evaluator
         return self
 
 

versionhq/task/model.py

@@ -8,7 +8,7 @@ from hashlib import md5
 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, field_validator
+from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, InstanceOf, field_validator
 from pydantic_core import PydanticCustomError
 
 from versionhq._utils.process_config import process_config
@@ -286,7 +286,7 @@ class Task(BaseModel):
     processed_by_agents: Set[str] = Field(default_factory=set, description="store responsible agents' roles")
     tools_errors: int = 0
     delegations: int = 0
-    latency: int | float = 0 # execution latency in sec
+    latency: int | float = 0 # job latency in sec
     tokens: int = 0 # tokens consumed
 
 
@@ -412,37 +412,38 @@ Ref. Output image: {output_formats_to_follow}
 
         response_format: Dict[str, Any] = None
 
-        # match model_provider:
-        #     case "openai":
-        if self.response_fields:
-            properties, required_fields = {}, []
-            for i, item in enumerate(self.response_fields):
-                if item:
-                    if item.data_type is dict:
-                        properties.update(item._format_props())
-                    else:
-                        properties.update(item._format_props())
-
-                    required_fields.append(item.title)
-
-            response_schema = {
-                "type": "object",
-                "properties": properties,
-                "required": required_fields,
-                "additionalProperties": False,
-            }
+        if model_provider == "openrouter":
+            return response_format
 
-            response_format = {
-                "type": "json_schema",
-                "json_schema": { "name": "outcome", "schema": response_schema }
-            }
+        else:
+            if self.response_fields:
+                properties, required_fields = {}, []
+                for i, item in enumerate(self.response_fields):
+                    if item:
+                        if item.data_type is dict:
+                            properties.update(item._format_props())
+                        else:
+                            properties.update(item._format_props())
+
+                        required_fields.append(item.title)
+
+                response_schema = {
+                    "type": "object",
+                    "properties": properties,
+                    "required": required_fields,
+                    "additionalProperties": False,
+                }
+
+                response_format = {
+                    "type": "json_schema",
+                    "json_schema": { "name": "outcome", "schema": response_schema }
+                }
 
 
-        elif self.pydantic_output:
-            response_format = StructuredOutput(response_format=self.pydantic_output)._format()
+            elif self.pydantic_output:
+                response_format = StructuredOutput(response_format=self.pydantic_output)._format()
 
-            # case "gemini":
-        return response_format
+            return response_format
 
 
     def _create_json_output(self, raw: str) -> Dict[str, Any]:
@@ -612,7 +613,7 @@ Ref. Output image: {output_formats_to_follow}
         task_output: InstanceOf[TaskOutput] = None
         tool_output: str | list = None
         task_tools: List[List[InstanceOf[Tool]| InstanceOf[ToolSet] | Type[Tool]]] = []
-        started_at = datetime.datetime.now()
+        started_at, ended_at = datetime.datetime.now(), datetime.datetime.now()
 
         if self.tools:
             for item in self.tools:
@@ -638,11 +639,16 @@ 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)
-            task_output = TaskOutput(task_id=self.id, tool_output=tool_output, raw=tool_output)
+            ended_at = datetime.datetime.now()
+            task_output = TaskOutput(task_id=self.id, tool_output=tool_output, raw=str(tool_output) if tool_output else "")
 
         else:
+            started_at = datetime.datetime.now()
             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)
             if "outcome" in json_dict_output:
                 json_dict_output = self._create_json_output(raw=str(json_dict_output["outcome"]))
@@ -656,9 +662,8 @@ Ref. Output image: {output_formats_to_follow}
                 json_dict=json_dict_output
             )
 
-        ended_at = datetime.datetime.now()
-        self.latency = (ended_at - started_at).total_seconds()
 
+        self.latency = (ended_at - started_at).total_seconds()
         self.output = task_output
         self.processed_by_agents.add(agent.role)
 

versionhq/team/model.py

@@ -20,7 +20,6 @@ from versionhq._utils.usage_metrics import UsageMetrics
 
 initial_match_type = GenerateSchema.match_type
 
-
 def match_type(self, obj):
     if getattr(obj, "__name__", None) == "datetime":
         return core_schema.datetime_schema()
@@ -28,7 +27,6 @@ def match_type(self, obj):
 
 
 GenerateSchema.match_type = match_type
-
 warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
 load_dotenv(override=True)
 
@@ -108,9 +106,14 @@ class TeamOutput(BaseModel):
 
 
 class TeamMember(BaseModel):
-    agent: Agent | None = Field(default=None, description="store the agent to be a member")
+    """
+    A class to store a team member
+    """
+    agent: Agent | None = Field(default=None)
     is_manager: bool = Field(default=False)
-    task: Optional[Task] = Field(default=None)
+    can_share_knowledge: bool = Field(default=True, description="whether to share the agent's knowledge in the team")
+    can_share_memory: bool = Field(default=True, description="whether to share the agent's memory in the team")
+    task: Optional[Task] = Field(default=None, description="task assigned to the agent")
 
     @property
     def is_idling(self):
@@ -125,17 +128,18 @@ class Team(BaseModel):
 
     __hash__ = object.__hash__
     _execution_span: Any = PrivateAttr()
-    _logger: Logger = PrivateAttr()
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
     _inputs: Optional[Dict[str, Any]] = PrivateAttr(default=None)
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None)
-    members: List[TeamMember] = Field(default_factory=list, description="store agents' uuids and bool if it is manager")
+    members: List[TeamMember] = Field(default_factory=list)
+
+    # formation planning
+    planning_llm: Optional[Any] = Field(default=None, description="llm to generate formation")
+    team_tasks: Optional[List[Task]] = Field(default_factory=list, description="optional tasks for the team. can be assigned to team members later")
 
-    # work as a team
-    team_tasks: Optional[List[Task]] = Field(default_factory=list, description="optional tasks for the team")
-    planning_llm: Optional[Any] = Field(default=None, description="llm to handle the planning of the team tasks (if any)")
-    function_calling_llm: Optional[Any] = Field(default=None, description="llm to execute func after all agent execution (if any)")
+    # task execution rules
     prompt_file: str = Field(default="", description="path to the prompt json file to be used by the team.")
     process: TaskHandlingProcess = Field(default=TaskHandlingProcess.sequential)
 
@@ -150,7 +154,6 @@ class Team(BaseModel):
     )
     step_callback: Optional[Any] = Field(default=None, description="callback to be executed after each step for all agents execution")
 
-    verbose: bool = Field(default=True)
     cache: bool = Field(default=True)
     memory: bool = Field(default=False, description="whether the team should use memory to store memories of its execution")
     execution_logs: List[Dict[str, Any]] = Field(default=[], description="list of execution logs for tasks")
@@ -236,7 +239,7 @@ class Team(BaseModel):
         return self
 
 
-    def _get_responsible_agent(self, task: Task) -> Agent:
+    def _get_responsible_agent(self, task: Task) -> Agent | None:
         if task is None:
             return None
         else:
@@ -244,7 +247,7 @@ class Team(BaseModel):
             return None if len(res) == 0 else res[0]
 
 
-    def _handle_team_planning(self) -> None:
+    def _handle_agent_formation(self) -> None:
         """
         Form a team considering agents and tasks given, and update `self.members` field:
             1. Idling managers to take the team tasks.
@@ -373,7 +376,7 @@ class Team(BaseModel):
 
             responsible_agent = self._get_responsible_agent(task)
             if responsible_agent is None:
-                self._handle_team_planning()
+                self._handle_agent_formation()
 
             if isinstance(task, ConditionalTask):
                 skipped_task_output = task._handle_conditional_task(task_outputs, futures, task_index, was_replayed)
@@ -415,7 +418,7 @@ class Team(BaseModel):
         metrics: List[UsageMetrics] = []
 
         if self.team_tasks or self.member_tasks_without_agent:
-            self._handle_team_planning()
+            self._handle_agent_formation()
 
         if kwargs_before is not None:
             for before_callback in self.before_kickoff_callbacks:
@@ -432,9 +435,6 @@ class Team(BaseModel):
             agent = member.agent
             agent.team = self
 
-            if not agent.function_calling_llm and self.function_calling_llm:
-                agent.function_calling_llm = self.function_calling_llm
-
             if self.step_callback:
                 agent.callbacks.append(self.step_callback)
 

{versionhq-1.1.11.7.dist-info → versionhq-1.1.12.1.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Version IO Sdn. Bhd.
+Copyright (c) 2024-2025 Version IO Sdn. Bhd.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{versionhq-1.1.11.7.dist-info → versionhq-1.1.12.1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.1.11.7
+Version: 1.1.12.1
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
         
-        Copyright (c) 2024 Version IO Sdn. Bhd.
+        Copyright (c) 2024-2025 Version IO Sdn. Bhd.
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal
@@ -78,12 +78,12 @@ Requires-Dist: numpy>=1.26.4; extra == "numpy"
 
 ![MIT license](https://img.shields.io/badge/License-MIT-green)
 [![Publisher](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml/badge.svg)](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml)
-![PyPI](https://img.shields.io/badge/PyPI->=v1.1.11.4-blue)
-![python ver](https://img.shields.io/badge/Python->=3.12-purple)
+![PyPI](https://img.shields.io/badge/PyPI-v1.1.12+-blue)
+![python ver](https://img.shields.io/badge/Python-3.11+-purple)
 ![pyenv ver](https://img.shields.io/badge/pyenv-2.5.0-orange)
 
 
-LLM orchestration frameworks to deploy multi-agent systems with task-based formation.
+LLM orchestration frameworks to deploy multi-agent systems and automate complex tasks with network formations.
 
 **Visit:**
 
@@ -122,15 +122,16 @@ LLM orchestration frameworks to deploy multi-agent systems with task-based forma
 
 ## Key Features
 
-Generate mulit-agent systems depending on the complexity of the task, and execute the task with agents of choice.
+Generate multi-agent systems based on the task complexity, execute tasks, and evaluate output based on the given criteria.
 
-Model-agnostic agents can handle RAG tools, tools, callbacks, and knowledge sharing among other agents.
+Agents are model-agnostic, and can handle and share RAG tools, knowledge, memory, and callbacks among other agents. (self-learn)
 
 
 ###  Agent formation
-Depending on the task complexity, agents can make a different formation.
 
-You can specify which formation you want them to generate, or let the agent decide if you don’t have a clear plan.
+Agents adapt their formation based on task complexity.
+
+You can specify a desired formation or allow the agents to determine it autonomously (default).
 
 
 |  | **Solo Agent** | **Supervising** | **Network** | **Random** |

{versionhq-1.1.11.7.dist-info → versionhq-1.1.12.1.dist-info}/RECORD

@@ -1,13 +1,13 @@
-versionhq/__init__.py,sha256=P2XOAcL21Bc7HXFQRtWWRJG5a1XB3GZSv86y7GHlZfc,863
+versionhq/__init__.py,sha256=oJDsufVGH28Hszr45GDKyjfs_OKDZaNrAhMOS4f9RmY,1031
 versionhq/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
-versionhq/_utils/logger.py,sha256=U-MpeGueA6YS8Ptfy0VnU_ePsZP-8Pvkvi0tZ4s_UMg,1438
+versionhq/_utils/logger.py,sha256=j9SlQPIefdVUlwpGfJY83E2BUt1ejWgZ2M2I8aMyQ3c,1579
 versionhq/_utils/process_config.py,sha256=jbPGXK2Kb4iyCugJ3FwRJuU0wL5Trq2x4xFQz2uOyFY,746
 versionhq/_utils/usage_metrics.py,sha256=hhq1OCW8Z4V93vwW2O2j528EyjOlF8wlTsX5IL-7asA,1106
 versionhq/_utils/vars.py,sha256=bZ5Dx_bFKlt3hi4-NNGXqdk7B23If_WaTIju2fiTyPQ,57
 versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent/default_agents.py,sha256=Sea3xDswxxMccer1vVDhp1E5etXW3ddf2n20JTMHgqs,503
-versionhq/agent/model.py,sha256=AL0t_knk_PX-mLO8a9PKxt12MavSraBHNLynI4ezpq8,24779
+versionhq/agent/inhouse_agents.py,sha256=DLwSREmFICF0Wv9IvEXp0gu1yOXJYOex0980Vi0NRWw,913
+versionhq/agent/model.py,sha256=1Y5au6ue6B4UbtoBL00kVATbl_0_IzY_-SBkuzVvL94,22423
 versionhq/agent/parser.py,sha256=riG0dkdQCxH7uJ0AbdVdg7WvL0BXhUgJht0VtQvxJBc,4082
 versionhq/agent/rpm_controller.py,sha256=7AKIEPbWBq_ESOZCaiKVOGjfSPHd2qwg6-wbBlhqC0g,2367
 versionhq/agent/TEMPLATES/Backstory.py,sha256=IAhGnnt6VUMe3wO6IzeyZPDNu7XE7Uiu3VEXUreOcKs,532
@@ -25,11 +25,11 @@ versionhq/knowledge/_utils.py,sha256=YWRF8U533cfZes_gZqUvdj-K24MD2ri1R0gjc_aPYyc
 versionhq/knowledge/embedding.py,sha256=KfHc__1THxb5jrg1EMrF-v944RDuIr2hE0l-MtM3Bp0,6826
 versionhq/knowledge/model.py,sha256=n7kU4jQ24BUIxwosSVRK8tYhAFYhgc4yf7e4Q-bq4bk,1832
 versionhq/knowledge/source.py,sha256=WOARChmm_cNtBD-xGo4RoYmcuodzdalctXI-gDBCW6k,13610
-versionhq/knowledge/source_docling.py,sha256=uj7mX1VjUr3cucAjZCuRcrKNQdae38I8Y7KyXrcqaS8,5322
+versionhq/knowledge/source_docling.py,sha256=hhHn3rS4KVsFKEPWcfllM8VxSL86PckZdAHDZNQNOq8,5411
 versionhq/knowledge/storage.py,sha256=7oxCg3W9mFjYH1YmuH9kFtTbNxquzYFjuUjd_TlsB9E,8170
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/llm/llm_vars.py,sha256=f8kPWKYLt5pPDqXQ4-McoUySM15J4N7a3tHMoMaxNzs,9264
-versionhq/llm/model.py,sha256=FACbUOPmhyatO34sXj7KI4HlHUmjujc-7KX8MfInpLc,14064
+versionhq/llm/llm_vars.py,sha256=asJtkKCcD0WWIbyVn7CYOWg-WZ6MSKS9lIRaYIkdib4,6778
+versionhq/llm/model.py,sha256=wSjRGyk9AZtvDqNfcyyeOMoV_hpTaUHCM849hBF0MhU,15145
 versionhq/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/memory/contextual_memory.py,sha256=tCsOOAUnfrOL7YiakqGoi3uShzzS870TmGnlGd3z_A4,3556
 versionhq/memory/model.py,sha256=6Sy-cnrhHNIx3ZN38uNO7d8YywIl_uo_OvDVzVM-w14,5755
@@ -41,14 +41,14 @@ versionhq/storage/rag_storage.py,sha256=fBk-RJuFRPOH4gI9E67tkhJnTBoChWocSP2PdWUY
 versionhq/storage/task_output_storage.py,sha256=gCsZywZ2SaNA1pYIsJk6BTrcpGp79TZTviZkWQF5USs,4579
 versionhq/storage/utils.py,sha256=ByYXPoEIGJYLUqz-DWjbCAnneNrH1otiYbp12SCILpM,747
 versionhq/task/__init__.py,sha256=l2r_g01i91JAGlOoHZP_Gh2WCk6mo9D19lcqt7sKMpQ,186
-versionhq/task/evaluate.py,sha256=RCaFa9N4IibAYLWKUlTn6lWiQoI7t4f_XZVUvecjTxs,3486
+versionhq/task/evaluate.py,sha256=sG_PFotpuRbDLW0rGDULseBk1uP8I0vYYtkh1npO0KE,3374
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
 versionhq/task/log_handler.py,sha256=KJRrcNZgFSKhlNzvtYFnvtp6xukaF1s7ifX9u4zWrN8,1683
-versionhq/task/model.py,sha256=ACHtRG2xtcSKin70wSp4GHg_B3wnPguaoVekESbG8VU,30134
+versionhq/task/model.py,sha256=kR4oqoT44xVbbTGK-gtVdfMz3m-riV62XumzRyqomiU,30418
 versionhq/task/structured_response.py,sha256=YxuWcDMHcZLzdxI1ihW99Y-i6nl8yXBQ5Q_dFQac8jw,4837
 versionhq/task/TEMPLATES/Description.py,sha256=bChflSWGGQo9JpnO6QX6Ng9pnONiTf-zwQ3ke4xQgSQ,357
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/team/model.py,sha256=NzcRXWwP0adWL9vsnsmI-A5dOcE3199FGmGgemUB2VA,20043
+versionhq/team/model.py,sha256=MgjqigmEDLnmDzYfVnbGnwp7MeXmZ-zsgyWR2Vb2FAU,20036
 versionhq/team/team_planner.py,sha256=UyIpw7GoRQXlgLNaojoi-G8F1sYaf5hTpLcTvWjRvlA,3596
 versionhq/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/tool/cache_handler.py,sha256=iL8FH7X0G-cdT0uhJwzuhLDaadTXOdfybZcDy151-es,1085
@@ -57,8 +57,8 @@ versionhq/tool/composio_tool_vars.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtg
 versionhq/tool/decorator.py,sha256=C4ZM7Xi2gwtEMaSeRo-geo_g_MAkY77WkSLkAuY0AyI,1205
 versionhq/tool/model.py,sha256=7ccEnje_8LuxLVeog6pL38nToArXQXk4KY7A9hfprDo,12239
 versionhq/tool/tool_handler.py,sha256=2m41K8qo5bGCCbwMFferEjT-XZ-mE9F0mDUOBkgivOI,1416
-versionhq-1.1.11.7.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
-versionhq-1.1.11.7.dist-info/METADATA,sha256=Rra00hIoAMSKGzNfYAW0MfaXZ1g2bffT37D0yCutvao,18672
-versionhq-1.1.11.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.1.11.7.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.1.11.7.dist-info/RECORD,,
+versionhq-1.1.12.1.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.1.12.1.dist-info/METADATA,sha256=rPZzAQlTUGo_Fh7FUyQFBELbuzxAOqnC9b83z-qvv20,18694
+versionhq-1.1.12.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.1.12.1.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.12.1.dist-info/RECORD,,

versionhq/agent/default_agents.py

@@ -1,15 +0,0 @@
-from versionhq.agent.model import Agent
-from versionhq.llm.model import DEFAULT_MODEL_NAME
-
-"""
-List up agents to be called across the project.
-"""
-
-client_manager = Agent(role="Client Manager", goal="communicate with clients on the task progress", llm=DEFAULT_MODEL_NAME)
-
-task_evaluator = Agent(
-    role="Task Evaluator",
-    goal="score the output according to the given evaluation criteria.",
-    llm=DEFAULT_MODEL_NAME,
-    llm_config=dict(top_p=0.8, top_k=30, max_tokens=5000, temperature=0.9)
-)