versionhq 1.1.11.6__py3-none-any.whl → 1.1.11.8__py3-none-any.whl

versionhq/__init__.py

@@ -17,7 +17,7 @@ from versionhq.tool.model import Tool
 from versionhq.tool.composio_tool import ComposioHandler
 
 
-__version__ = "1.1.11.6"
+__version__ = "1.1.11.8"
 __all__ = [
     "Agent",
     "Customer",

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
@@ -99,7 +99,7 @@ class Agent(BaseModel):
     tools: Optional[List[InstanceOf[Tool | ToolSet] | Type[Tool] | Any]] = Field(default_factory=list)
 
     # knowledge
-    knowledge_sources: Optional[List[BaseKnowledgeSource]] = Field(default=None)
+    knowledge_sources: Optional[List[BaseKnowledgeSource | Any]] = Field(default=None)
     _knowledge: Optional[Knowledge] = PrivateAttr(default=None)
 
     # memory
@@ -162,90 +162,44 @@ 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._set_llm(llm=self.llm)
+        function_calling_llm = self.function_calling_llm if self.function_calling_llm else self.llm if self.llm else None
+        self.function_calling_llm = self._set_llm(llm=function_calling_llm)
+        return self
 
-        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
+    def _set_llm(self, llm: Any | None) -> LLM:
+        llm = llm if llm is not None else DEFAULT_MODEL_NAME
 
-        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
+        match llm:
+            case LLM():
+                return self._set_llm_params(llm=llm)
 
-            else:
+            case str():
+                llm_obj = LLM(model=llm)
+                return self._set_llm_params(llm=llm_obj)
+
+            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 })
+
+            case _:
                 model_name = (getattr(self.llm, "model_name") or getattr(self.llm, "deployment_name") or str(self.llm))
-                llm = LLM(model=model_name)
+                llm_obj = 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),
+                    "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),
                 }
-                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
-
-            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)
-
-                updated_llm = self._set_llm_params(llm)
-                self.function_calling_llm = updated_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
-
-                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
-
-        return self
+                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 +211,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)
@@ -344,14 +303,46 @@ class Agent(BaseModel):
 
     @model_validator(mode="after")
     def set_up_knowledge(self) -> Self:
-        if self.knowledge_sources:
-            collection_name = f"{self.role.replace(' ', '_')}"
+        from versionhq.knowledge.source import BaseKnowledgeSource, StringKnowledgeSource, TextFileKnowledgeSource, CSVKnowledgeSource, ExcelKnowledgeSource, JSONKnowledgeSource
+        from versionhq.knowledge.source_docling import DoclingSource
 
-            self._knowledge = Knowledge(
-                sources=self.knowledge_sources,
-                embedder_config=self.embedder_config,
-                collection_name=collection_name,
-            )
+        if self.knowledge_sources:
+            try:
+                collection_name = f"{self.role.replace(' ', '_')}"
+                knowledge_sources = []
+                docling_fp, txt_fp, json_fp, excel_fp, csv_fp, pdf_fp = [], [], [], [], [], []
+                str_cont = ""
+
+                for item in self.knowledge_sources:
+                    if isinstance(item, BaseKnowledgeSource):
+                        knowledge_sources.append(item)
+
+                    elif isinstance(item, str) and "http" in item:
+                        docling_fp.append(item)
+
+                    elif isinstance(item, str):
+                        match  os.path.splitext(item)[1]:
+                            case ".txt": txt_fp.append(item)
+                            case ".json": json_fp.append(item)
+                            case ".xls" | ".xlsx": excel_fp.append(item)
+                            case ".pdf": pdf_fp.append(item)
+                            case ".csv": csv_fp.append(item)
+                            case _: str_cont += str(item)
+
+                    else:
+                        str_cont += str(item)
+
+                if docling_fp: knowledge_sources.append(DoclingSource(file_paths=docling_fp))
+                if str_cont: knowledge_sources.append(StringKnowledgeSource(content=str_cont))
+                if txt_fp: knowledge_sources.append(TextFileKnowledgeSource(file_paths=txt_fp))
+                if csv_fp: knowledge_sources.append(CSVKnowledgeSource(file_path=csv_fp))
+                if excel_fp: knowledge_sources.append(ExcelKnowledgeSource(file_path=excel_fp))
+                if json_fp: knowledge_sources.append(JSONKnowledgeSource(file_paths=json_fp))
+
+                self._knowledge = Knowledge(sources=knowledge_sources, embedder_config=self.embedder_config, collection_name=collection_name)
+
+            except:
+                self._logger.log(level="warning", message="We cannot find the format for the source. Add BaseKnowledgeSource objects instead.", color="yellow")
 
         return self
 
@@ -414,7 +405,7 @@ class Agent(BaseModel):
             self._logger.log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
 
             if tool_res_as_final:
-                func_llm = self.function_calling_llm if self.function_calling_llm and self.function_calling_llm._supports_function_calling() else LLM(model=DEFAULT_MODEL_NAME)
+                func_llm = self.function_calling_llm if self.function_calling_llm and self.function_calling_llm._supports_function_calling() else self.llm if self.llm and self.llm._supports_function_calling() else LLM(model=DEFAULT_MODEL_NAME)
                 raw_response = func_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
                 task.tokens = func_llm._tokens
             else:
@@ -458,7 +449,7 @@ class Agent(BaseModel):
         from versionhq.knowledge._utils import extract_knowledge_context
 
         task: InstanceOf[Task] = task
-        tools: Optional[List[InstanceOf[Tool]| InstanceOf[ToolSet] | Type[Tool]]] = task_tools + self.tools if task.can_use_agent_tools else task_tools
+        tools: Optional[List[InstanceOf[Tool | ToolSet] | Type[Tool]]] = task_tools + self.tools if task.can_use_agent_tools else task_tools
 
         if self.max_rpm and self._rpm_controller:
             self._rpm_controller._reset_request_count()
@@ -474,7 +465,6 @@ class Agent(BaseModel):
                 if agent_knowledge_context:
                     task_prompt += agent_knowledge_context
 
-
         if self.use_memory == True:
             contextual_memory = ContextualMemory(
                 memory_config=self.memory_config, stm=self.short_term_memory, ltm=self.long_term_memory, um=self.user_memory

versionhq/knowledge/source_docling.py

@@ -3,7 +3,6 @@ from typing import Iterator, List, Optional
 from urllib.parse import urlparse
 
 try:
-    import docling
     from docling.datamodel.base_models import InputFormat
     from docling.document_converter import DocumentConverter
     from docling.exceptions import ConversionError
@@ -12,19 +11,12 @@ try:
     DOCLING_AVAILABLE = True
 except ImportError:
     import envoy
-    r = envoy.run("uv add docling --optional docling")
-
-    import 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
+    envoy.run("uv add docling --optional docling")
     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
@@ -54,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

@@ -3,6 +3,33 @@ from typing import Type
 
 JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
 
+PROVIDERS = [
+    "openai",
+    "gemini",
+    "sagemaker",
+    "huggingface", # need api base
+    "anthropic",
+    "ollama",
+    "watson",
+    "bedrock",
+    "azure",
+    "cerebras",
+    "llama",
+]
+
+ENDPOINT_PROVIDERS = [
+    # "openai",
+    # "gemini",
+    # "sagemaker",
+    "huggingface",
+    # "anthropic",
+    # "ollama",
+    # "watson",
+    # "bedrock",
+    # "azure",
+    # "cerebras",
+    # "llama",
+]
 
 """
 List of models available on the framework.
@@ -16,7 +43,6 @@ litellm.pick_cheapest_chat_models_from_llm_provider(custom_llm_provider: str, n=
 
 MODELS = {
     "openai": [
-        # "gpt-3.5-turbo",
         "gpt-4",
         "gpt-4o",
         "gpt-4o-mini",
@@ -27,11 +53,7 @@ MODELS = {
         "gemini/gemini-1.5-flash",
         "gemini/gemini-1.5-pro",
         "gemini/gemini-2.0-flash-exp",
-        # "gemini/gemini-gemma-2-9b-it",
-        # "gemini/gemini-gemma-2-27b-it",
     ],
-    # "vetrex_ai": [
-    # ],
     "anthropic": [
         "claude-3-5-sonnet-20241022",
         "claude-3-5-sonnet-20240620",
@@ -39,10 +61,28 @@ MODELS = {
         "claude-3-opus-20240229",
         "claude-3-haiku-20240307",
     ],
-    # "ollama": [
-    #   "ollama/llama3.1",
-    #   "ollama/mixtral",
-    # ],
+    "huggingface": [
+        "huggingface/qwen/qwen2.5-VL-72B-Instruct",
+    ],
+    # "sagemaker": [
+    #     "sagemaker/huggingface-text2text-flan-t5-base",
+    #     "sagemaker/huggingface-llm-gemma-7b",
+    #     "sagemaker/jumpstart-dft-meta-textgeneration-llama-2-13b",
+    #     "sagemaker/jumpstart-dft-meta-textgeneration-llama-2-70b",
+    #     "sagemaker/jumpstart-dft-meta-textgeneration-llama-3-8b",
+    #     "sagemaker/jumpstart-dft-meta-textgeneration-llama-3-70b",
+    #     "sagemaker/huggingface-llm-mistral-7b"
+    # ], #https://docs.aws.amazon.com/sagemaker/latest/dg/jumpstart-foundation-models-latest.html
+    "ollama": [
+      "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",
@@ -53,44 +93,48 @@ MODELS = {
     #     "watsonx/mistral/mistral-large",
     #     "watsonx/ibm/granite-3-8b-instruct",
     # ],
-    # "bedrock": [
-    #     "bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
-    #     "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",
-    #     "bedrock/meta.llama3-1-70b-instruct-v1:0",
-    #     "bedrock/meta.llama3-1-8b-instruct-v1:0",
-    #     "bedrock/meta.llama3-70b-instruct-v1:0",
-    #     "bedrock/meta.llama3-8b-instruct-v1:0",
-    #     "bedrock/amazon.titan-text-lite-v1",
-    #     "bedrock/amazon.titan-text-express-v1",
-    #     "bedrock/cohere.command-text-v14",
-    #     "bedrock/ai21.j2-mid-v1",
-    #     "bedrock/ai21.j2-ultra-v1",
-    #     "bedrock/ai21.jamba-instruct-v1:0",
-    #     "bedrock/meta.llama2-13b-chat-v1",
-    #     "bedrock/meta.llama2-70b-chat-v1",
-    #     "bedrock/mistral.mistral-7b-instruct-v0:2",
-    #     "bedrock/mistral.mixtral-8x7b-instruct-v0:1",
-    # ],
+    "bedrock": [
+        "bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
+        "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",
+        "bedrock/meta.llama3-1-70b-instruct-v1:0",
+        "bedrock/meta.llama3-1-8b-instruct-v1:0",
+        "bedrock/meta.llama3-70b-instruct-v1:0",
+        "bedrock/meta.llama3-8b-instruct-v1:0",
+        "bedrock/amazon.titan-text-lite-v1",
+        "bedrock/amazon.titan-text-express-v1",
+        "bedrock/cohere.command-text-v14",
+        "bedrock/ai21.j2-mid-v1",
+        "bedrock/ai21.j2-ultra-v1",
+        "bedrock/ai21.jamba-instruct-v1:0",
+        "bedrock/meta.llama2-13b-chat-v1",
+        "bedrock/meta.llama2-70b-chat-v1",
+        "bedrock/mistral.mistral-7b-instruct-v0:2",
+        "bedrock/mistral.mixtral-8x7b-instruct-v0:1",
+    ],
 }
 
 
-PROVIDERS = [
-    "openai",
-    "anthropic",
-    "gemini",
-    "ollama",
-    "watson",
-    "bedrock",
-    "azure",
-    "cerebras",
-    "llama",
-]
+
+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"],
+}
+
+
+"""
+Use base_url to specify
+"""
+BASE_URLS = {
+    "deepseek": "https://api.deepseek.com"
+}
 
 
 """
@@ -118,6 +162,8 @@ LLM_CONTEXT_WINDOW_SIZES = {
     "claude-3-haiku-20240307": 200000,
 
     "deepseek-chat": 128000,
+    "deepseek/deepseek-reasoner": 8192,
+
     "gemma2-9b-it": 8192,
     "gemma-7b-it": 8192,
     "llama3-groq-70b-8192-tool-use-preview": 8192,
@@ -135,11 +181,7 @@ LLM_CONTEXT_WINDOW_SIZES = {
 }
 
 
-LLM_API_KEY_NAMES = {
-    "openai":  "OPENAI_API_KEY",
-    "anthropic": "ANTHROPIC_API_KEY",
-    "gemini": "GEMINI_API_KEY",
-}
+
 
 LLM_BASE_URL_KEY_NAMES = {
     "openai":  "OPENAI_API_BASE",
@@ -262,14 +304,8 @@ PARAMS = {
     ],
     "openai": [
         "timeout",
-        # "temperature",
-        # "top_p",
-        # "n",
-        # "stream",
         "stream_options",
-        # "stop",
         "max_compl,etion_tokens",
-        # "max_tokens",
         "modalities",
         "prediction",
         "audio",
@@ -277,10 +313,7 @@ PARAMS = {
         "frequency_penalty",
         "logit_bias",
         "user",
-        # "response_format",
         "seed",
-        # "tools",
-        # "tool_choice",
         "logprobs",
         "top_logprobs",
         "parallel_tool_calls",

versionhq/llm/model.py

@@ -4,23 +4,16 @@ import os
 import sys
 import threading
 import warnings
-import litellm
-from litellm import JSONSchemaValidationError
-from abc import ABC
 from dotenv import load_dotenv
-from litellm import get_supported_openai_params
+import litellm
+from litellm import get_supported_openai_params, JSONSchemaValidationError
 from contextlib import contextmanager
-from typing import Any, Dict, List, Optional, Type
+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 import BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf, ConfigDict
 from pydantic_core import PydanticCustomError
 
-from openai import OpenAI
-
-from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES, LLM_API_KEY_NAMES, LLM_BASE_URL_KEY_NAMES, MODELS, PARAMS, SchemaType
-from versionhq.task import TaskOutputFormat
-from versionhq.task.model import ResponseField, Task
+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
 
@@ -29,10 +22,11 @@ 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")
+DEFAULT_MODEL_NAME = os.environ.get("DEFAULT_MODEL_NAME", "gpt-4o-mini")
+DEFAULT_MODEL_PROVIDER_NAME = os.environ.get("DEFAULT_MODEL_PROVIDER_NAME", "openai")
 
-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"))
+# 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"))
 
 
 class FilteredStream:
@@ -74,10 +68,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))
@@ -85,10 +76,11 @@ 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
     timeout: Optional[float | int] = Field(default=None)
@@ -121,55 +113,90 @@ 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:
+        """
+        After setting up a valid model, provider, interface provider, add params to the model.
+        """
+        self._tokens = 0
+
         if self.callbacks:
             self._set_callbacks(self.callbacks)
 
@@ -179,7 +206,9 @@ class LLM(BaseModel):
         if api_key_name:
             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
@@ -190,11 +219,8 @@ class LLM(BaseModel):
     def _create_valid_params(self, config: Dict[str, Any], provider: str = None) -> Dict[str, Any]:
         params = dict()
         valid_keys = list()
-
-        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)
+        provider = provider if provider else self.provider if self.provider else None
+        valid_keys = PARAMS.get("litellm") + PARAMS.get("common") + PARAMS.get(provider) if provider and PARAMS.get(provider) else PARAMS.get("litellm") + PARAMS.get("common")
 
         for item in valid_keys:
             if hasattr(self, item) and getattr(self, item):
@@ -224,7 +250,7 @@ class LLM(BaseModel):
                 self._set_callbacks(self.callbacks) # passed by agent
 
             try:
-                provider = self.provider if self.provider else "openai"
+                provider = self.provider if self.provider else DEFAULT_MODEL_PROVIDER_NAME
                 self.response_format = { "type": "json_object" } if tool_res_as_final == True else response_format
 
                 if not tools:
@@ -236,51 +262,51 @@ class LLM(BaseModel):
                 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 = openai_client.chat.completions.create(messages=messages, model=self.model, tools=self.tools)
-                        tool_calls = res.choices[0].message.tool_calls
-                        tool_res = ""
-
-                        for item in tool_calls:
-                            func_name = item.function.name
-                            func_args = item.function.arguments
+                    # if provider == "openai":
+                    params = self._create_valid_params(config=config, provider=provider)
+                    res = litellm.completion(messages=messages, model=self.model, tools=self.tools)
+                    tool_calls = res.choices[0].message.tool_calls
+                    tool_res = ""
+
+                    for item in tool_calls:
+                        func_name = item.function.name
+                        func_args = item.function.arguments
+
+                        if not isinstance(func_args, dict):
+                            try:
+                                func_args = json.loads(json.dumps(eval(str(func_args))))
+                            except:
+                                pass
+
+                        for tool in tools:
+                            if isinstance(tool, ToolSet) and (tool.tool.name == func_name or tool.tool.func.__name__ == func_name or func_name == "random_func"):
+                                tool_instance = tool.tool
+                                args = tool.kwargs
+                                tool_res_to_add = tool_instance.run(params=args)
+
+                                if tool_res_as_final:
+                                    tool_res += str(tool_res_to_add)
+                                else:
+                                    messages.append(res.choices[0].message)
+                                    messages.append({ "role": "tool", "tool_call_id": item.id, "content": str(tool_res_to_add) })
 
-                            if not isinstance(func_args, dict):
+                            else:
                                 try:
-                                    func_args = json.loads(json.dumps(eval(str(func_args))))
-                                except:
-                                    pass
-
-                            for tool in tools:
-                                if isinstance(tool, ToolSet) and (tool.tool.name == func_name or tool.tool.func.__name__ == func_name or func_name == "random_func"):
-                                    tool_instance = tool.tool
-                                    args = tool.kwargs
-                                    tool_res_to_add = tool_instance.run(params=args)
-
+                                    tool_res_to_add = tool.run(params=func_args)
                                     if tool_res_as_final:
                                         tool_res += str(tool_res_to_add)
                                     else:
                                         messages.append(res.choices[0].message)
                                         messages.append({ "role": "tool", "tool_call_id": item.id, "content": str(tool_res_to_add) })
+                                except:
+                                    pass
 
-                                else:
-                                    try:
-                                        tool_res_to_add = tool.run(params=func_args)
-                                        if tool_res_as_final:
-                                            tool_res += str(tool_res_to_add)
-                                        else:
-                                            messages.append(res.choices[0].message)
-                                            messages.append({ "role": "tool", "tool_call_id": item.id, "content": str(tool_res_to_add) })
-                                    except:
-                                        pass
-
-                        if tool_res_as_final:
-                            return tool_res
-                        else:
-                            res = openai_client.chat.completions.create(messages=messages, model=self.model, tools=self.tools)
-                            self._tokens += int(res["usage"]["total_tokens"])
-                            return res.choices[0].message.content
+                    if tool_res_as_final:
+                        return tool_res
+                    else:
+                        res = litellm.completione(messages=messages, model=self.model, tools=self.tools)
+                        self._tokens += int(res["usage"]["total_tokens"])
+                        return res.choices[0].message.content
 
             except JSONSchemaValidationError as e:
                 self._logger.log(level="error", message="Raw Response: {}".format(e.raw_response), color="red")

versionhq/task/model.py

@@ -412,6 +412,8 @@ 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):
@@ -439,6 +441,7 @@ Ref. Output image: {output_formats_to_follow}
         elif self.pydantic_output:
             response_format = StructuredOutput(response_format=self.pydantic_output)._format()
 
+            # case "gemini":
         return response_format
 
 
@@ -636,7 +639,7 @@ Ref. Output image: {output_formats_to_follow}
 
         if self.tool_res_as_final == True:
             tool_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
-            task_output = TaskOutput(task_id=self.id, tool_output=tool_output)
+            task_output = TaskOutput(task_id=self.id, tool_output=tool_output, raw=str(tool_output) if tool_output else "")
 
         else:
             raw_output = agent.execute_task(task=self, context=context, task_tools=task_tools)

versionhq/task/structured_response.py

@@ -82,12 +82,13 @@ class StructuredList:
 
                 if nested_object_type == dict:
                     props.update({
-                        "nest":  {
+                        # "nest":  {
                             "type": "object",
                             "properties": { "item": { "type": "string"} }, #! REFINEME - field title <>`item`
                             "required": ["item",],
                             "additionalProperties": False
-                        }})
+                        # }
+                        })
 
                 elif nested_object_type == list:
                     props.update({
@@ -110,7 +111,7 @@ class StructuredList:
 
 
 class StructuredOutput(BaseModel):
-    response_format: Any = None
+    response_format: Any = None # pydantic base model
     provider: str = "openai"
     applicable_models: List[InstanceOf[LLM] | str] = list()
     name: str = ""

{versionhq-1.1.11.6.dist-info → versionhq-1.1.11.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.1.11.6
+Version: 1.1.11.8
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -319,8 +319,10 @@ src/
    pyenv install 3.12.8
    pyenv global 3.12.8  (optional: `pyenv global system` to get back to the system default ver.)
    uv python pin 3.12.8
+   echo 3.12.8 > .python-version
    ```
 
+
 3. Set up environment variables:
    Create a `.env` file in the project root and add the following:
    ```

{versionhq-1.1.11.6.dist-info → versionhq-1.1.11.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=khEpIbv1gBkv7txiWOdTPlq7MYqe15UUyLe63UaP-ro,863
+versionhq/__init__.py,sha256=9QPw8-DjsW5Z2vOHQUBb-AMSyIR2RFcFkR42aXVbUFc,863
 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
@@ -7,7 +7,7 @@ versionhq/_utils/usage_metrics.py,sha256=hhq1OCW8Z4V93vwW2O2j528EyjOlF8wlTsX5IL-
 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=kL949N0MELAZz58XB_vlQfE1YQU_o4iHggNDn_h_7yo,22758
+versionhq/agent/model.py,sha256=U6kz8EE4tJYk9HBg4qeB2_-297ROEORxP_gE6C89aH0,22232
 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=Lv7PDE97pwV5_3SPcIgTzEu3H4obRbPfY3NALvfkgX8,5364
+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=PO__b-h5e-6oQ-uoIgXx3lPSAUPUwXYfdVRW73fvX14,8761
-versionhq/llm/model.py,sha256=1uaBxT10GIlUl-BtE8Mfux-ZRcScp4HUIas_fD_cdWQ,14471
+versionhq/llm/llm_vars.py,sha256=48IvN6w6h6QJUWqO0A44begGLoUbBaaS-HPO_wp7c84,9588
+versionhq/llm/model.py,sha256=0qe3oC5u42erVBHc76WRpDKH9PDTzXyaraIuDJ6bDAY,15426
 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
@@ -44,8 +44,8 @@ versionhq/task/__init__.py,sha256=l2r_g01i91JAGlOoHZP_Gh2WCk6mo9D19lcqt7sKMpQ,18
 versionhq/task/evaluate.py,sha256=RCaFa9N4IibAYLWKUlTn6lWiQoI7t4f_XZVUvecjTxs,3486
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
 versionhq/task/log_handler.py,sha256=KJRrcNZgFSKhlNzvtYFnvtp6xukaF1s7ifX9u4zWrN8,1683
-versionhq/task/model.py,sha256=Uxs5LaGb1O9CdnhWh36sSbgdKPfDYDCi2V4BNdvAMPc,30027
-versionhq/task/structured_response.py,sha256=h5GbbkCNJ27f4AbHcriGctQLFSp4qlmq2REDEfSd8xU,4786
+versionhq/task/model.py,sha256=DCm2jS0RFm4iPkepzKbNgODUdxOtGCV0RCINMaI0c_Q,30162
+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
@@ -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.6.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
-versionhq-1.1.11.6.dist-info/METADATA,sha256=6ApakYLq7bQHnNPx9kwvjTctXrXf7lYL4CJ-xTdPPgM,18638
-versionhq-1.1.11.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.1.11.6.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.1.11.6.dist-info/RECORD,,
+versionhq-1.1.11.8.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
+versionhq-1.1.11.8.dist-info/METADATA,sha256=VKscq6wLejKxh7fF2p6V9fbgRveRHbzAjVw5KcBwpTg,18672
+versionhq-1.1.11.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.1.11.8.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.11.8.dist-info/RECORD,,