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

versionhq/__init__.py

@@ -1,35 +1,71 @@
+# 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
 from versionhq.clients.product.model import Product, ProductProvider
 from versionhq.clients.workflow.model import MessagingWorkflow, MessagingComponent
-from versionhq.task.model import Task, TaskOutput
-from versionhq.team.model import Team, TeamOutput
-from versionhq.tool.model import Tool
+from versionhq.knowledge.model import Knowledge, KnowledgeStorage
+from versionhq.knowledge.source import PDFKnowledgeSource, CSVKnowledgeSource, JSONKnowledgeSource, TextFileKnowledgeSource, ExcelKnowledgeSource, StringKnowledgeSource
+from versionhq.knowledge.source_docling import DoclingSource
+from versionhq.task.model import Task, TaskOutput, ConditionalTask, ResponseField
+from versionhq.task.evaluate import Evaluation, EvaluationItem
+from versionhq.team.model import Team, TeamOutput, Formation, TeamMember, TaskHandlingProcess
+from versionhq.tool.model import Tool, ToolSet
+from versionhq.tool.cache_handler import CacheHandler
+from versionhq.tool.tool_handler import ToolHandler
 from versionhq.tool.composio_tool import ComposioHandler
+from versionhq.memory.contextual_memory import ContextualMemory
+from versionhq.memory.model import ShortTermMemory,LongTermMemory, UserMemory, MemoryItem
+
 
 
-__version__ = "1.1.11.8"
+__version__ = "1.1.12.2"
 __all__ = [
     "Agent",
+
     "Customer",
     "Product",
     "ProductProvider",
     "MessagingWorkflow",
     "MessagingComponent",
-    "LLM",
+
+    "Knowledge",
+    "KnowledgeStorage",
+    "PDFKnowledgeSource",
+    "CSVKnowledgeSource",
+    "JSONKnowledgeSource",
+    "TextFileKnowledgeSource",
+    "ExcelKnowledgeSource",
+    "StringKnowledgeSource",
+    "DoclingSource",
+
     "Task",
     "TaskOutput",
+    "ConditionalTask",
+    "ResponseField",
+
+    "Evaluation",
+    "EvaluationItem",
+
     "Team",
     "TeamOutput",
+    "Formation",
+    "TeamMember",
+    "TaskHandlingProcess",
+
     "Tool",
-    "ComposioHandler"
+    "ToolSet",
+    "CacheHandler",
+    "ToolHandler",
+    "ComposioHandler",
+
+    "ContextualMemory",
+    "ShortTermMemory",
+    "LongTermMemory",
+    "UserMemory",
+    "MemoryItem"
 ]

versionhq/_utils/__init__.py

@@ -0,0 +1,3 @@
+from versionhq._utils.logger import Logger
+from versionhq._utils.process_config import process_config
+from versionhq._utils.usage_metrics import UsageMetrics

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,41 @@
+from versionhq.agent.model import Agent
+from versionhq.llm.model import DEFAULT_MODEL_NAME
+
+"""
+In-house agents to be called across the project.
+[Rules] In house agents have names and roles that start with `vhq_`. No customization allowed by client.
+"""
+
+vhq_client_manager = Agent(
+    role="vhq-Client Manager",
+    goal="Efficiently communicate with the client on the task progress",
+    llm=DEFAULT_MODEL_NAME,
+    use_memory=True,
+)
+
+
+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,
+    use_memory=True # refer past eval records of similar tasks
+)
+
+
+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,
+    knowledge_sources=[
+        "Solo is a formation where a single agent with tools, knowledge, and memory handles tasks indivudually. When self-learning mode is on - it will turn into Random formation. Typical usecase is an email agent drafts promo message for the given audience using their own knowledge.",
+        "Supervising is a formation where the leader agent gives directions, while sharing its knowledge and memory with subbordinates.Subordinates can be solo agents or networks. Typical usecase is that the leader agent strategizes an outbound campaign plan and assigns components such as media mix or message creation to subordinate agents.",
+        "Network is a formation where multple agents can share tasks, knowledge, and memory among network members without hierarchy. Typical usecase is that an email agent and social media agent share the product knowledge and deploy multi-channel outbound campaign. ",
+        "Random is a formation where a single agent handles tasks, asking help from other agents without sharing its memory or knowledge. Typical usecase is that an email agent drafts promo message for the given audience, asking insights on tones from other email agents which oversee other customer clusters, or an agent calls the external, third party agent to deploy the campaign. ",
+    ]
+)

versionhq/agent/model.py

@@ -1,6 +1,5 @@
 import os
 import uuid
-import datetime
 from typing import Any, Dict, List, Optional, TypeVar, Callable, Type
 from typing_extensions import Self
 from dotenv import load_dotenv
@@ -165,13 +164,16 @@ class Agent(BaseModel):
         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)
+        self.llm = self._convert_to_llm_class(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)
+        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
 
 
-    def _set_llm(self, llm: Any | None) -> LLM:
+    def _convert_to_llm_class(self, llm: Any | None) -> LLM:
         llm = llm if llm is not None else DEFAULT_MODEL_NAME
 
         match llm:
@@ -350,7 +352,7 @@ class Agent(BaseModel):
     @model_validator(mode="after")
     def set_up_memory(self) -> Self:
         """
-        Set up memories: stm, um
+        Set up memories: stm, ltm, and um
         """
 
         if self.use_memory == True:
@@ -413,7 +415,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:
@@ -429,7 +431,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:
@@ -474,6 +476,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/agent/rpm_controller.py

@@ -5,7 +5,7 @@ from typing_extensions import Self
 
 from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
-from versionhq._utils.logger import Logger
+from versionhq._utils import Logger
 
 
 class RPMController(BaseModel):

versionhq/clients/product/model.py

@@ -56,7 +56,6 @@ class ProductProvider(ABC, BaseModel):
         return self
 
 
-
 class Product(BaseModel):
     """
     A class to store product information used to create outbound

versionhq/knowledge/__init__.py

@@ -0,0 +1,22 @@
+from versionhq.knowledge.model import Knowledge, KnowledgeStorage
+from versionhq.knowledge.source import (
+    CSVKnowledgeSource,
+    ExcelKnowledgeSource,
+    PDFKnowledgeSource,
+    TextFileKnowledgeSource,
+    JSONKnowledgeSource,
+    StringKnowledgeSource
+)
+from versionhq.knowledge.source_docling import DoclingSource
+
+__all__ = [
+    "Knowledge",
+    "KnowledgeStorage",
+    "DoclingSource",
+    "CSVKnowledgeSource",
+    "ExcelKnowledgeSource",
+    "PDFKnowledgeSource",
+    "TextFileKnowledgeSource",
+    "JSONKnowledgeSource",
+    "StringKnowledgeSource"
+]

versionhq/knowledge/model.py

@@ -1,5 +1,3 @@
-import os
-from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional
 from pydantic import BaseModel, ConfigDict, Field
 

versionhq/knowledge/source.py

@@ -280,7 +280,6 @@ class PDFKnowledgeSource(BaseFileKnowledgeSource):
 
 
 
-
 class CSVKnowledgeSource(BaseFileKnowledgeSource):
     """
     A knowledge source class that stores and queries CSV file content using embeddings.

versionhq/llm/llm_vars.py

@@ -6,29 +6,20 @@ JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_
 PROVIDERS = [
     "openai",
     "gemini",
-    "sagemaker",
-    "huggingface", # need api base
+    "openrouter",
+    "huggingface",
     "anthropic",
+    "sagemaker",
+    "bedrock",
     "ollama",
     "watson",
-    "bedrock",
     "azure",
     "cerebras",
     "llama",
 ]
 
 ENDPOINT_PROVIDERS = [
-    # "openai",
-    # "gemini",
-    # "sagemaker",
     "huggingface",
-    # "anthropic",
-    # "ollama",
-    # "watson",
-    # "bedrock",
-    # "azure",
-    # "cerebras",
-    # "llama",
 ]
 
 """
@@ -57,10 +48,14 @@ 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",
     ],
@@ -78,11 +73,6 @@ MODELS = {
       "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",
@@ -98,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",
@@ -124,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,
@@ -160,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,
@@ -177,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,12 +5,11 @@ 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 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, PROVIDERS, ENDPOINT_PROVIDERS
 from versionhq.tool.model import Tool, ToolSet
@@ -25,10 +23,6 @@ DEFAULT_CONTEXT_WINDOW_SIZE = int(8192 * 0.75)
 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"))
-
-
 class FilteredStream:
     def __init__(self, original_stream):
         self._original_stream = original_stream
@@ -53,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)
@@ -83,11 +78,11 @@ class LLM(BaseModel):
     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)
@@ -98,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")
@@ -193,7 +188,7 @@ class LLM(BaseModel):
     @model_validator(mode="after")
     def validate_model_params(self) -> Self:
         """
-        After setting up a valid model, provider, interface provider, add params to the model.
+        Set up valid params to the model after setting up a valid model, provider, interface provider names.
         """
         self._tokens = 0
 
@@ -216,19 +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()
-        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")
+    def _create_valid_params(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Return valid params (model + litellm original params) from the given config dict.
+        """
+
+        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(
@@ -250,21 +254,18 @@ class LLM(BaseModel):
                 self._set_callbacks(self.callbacks) # passed by agent
 
             try:
-                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:
                     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 = ""
 
@@ -304,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
 
@@ -320,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: