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

versionhq/__init__.py

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

versionhq/agent/model.py

@@ -1,6 +1,6 @@
 import os
 import uuid
-from typing import Any, Dict, List, Optional, TypeVar
+from typing import Any, Dict, List, Optional, TypeVar, Callable
 from typing_extensions import Self
 from dotenv import load_dotenv
 from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator
@@ -9,8 +9,8 @@ from pydantic_core import PydanticCustomError
 from versionhq._utils.logger import Logger
 from versionhq._utils.rpm_controller import RPMController
 from versionhq._utils.usage_metrics import UsageMetrics
-from versionhq.llm.llm_vars import LLM_VARS
-from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW
+from versionhq.llm.llm_variables import LLM_VARS
+from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW_SIZE, DEFAULT_MODEL_NAME
 from versionhq.task import TaskOutputFormat
 from versionhq.task.model import ResponseField
 from versionhq.tool.model import Tool, ToolSet
@@ -87,6 +87,7 @@ class Agent(BaseModel):
     _request_within_rpm_limit: Any = PrivateAttr(default=None)
     _token_process: TokenProcess = PrivateAttr(default_factory=TokenProcess)
     _times_executed: int = PrivateAttr(default=0)
+    config: Optional[Dict[str, Any]] = Field(default=None, exclude=True, description="values to add to the Agent class")
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     role: str = Field(description="role of the agent - used in summary and logs")
@@ -102,11 +103,11 @@ class Agent(BaseModel):
     allow_code_execution: Optional[bool] = Field(default=False, description="Enable code execution for the agent.")
     max_retry_limit: int = Field(default=2,description="max. number of retries for the task execution when an error occurs. cascaed to the `invoke` function")
     max_iter: Optional[int] = Field(default=25,description="max. number of iterations for an agent to execute a task")
-    step_callback: Optional[Any] = Field(default=None,description="Callback to be executed after each step of the agent execution")
+    step_callback: Optional[Callable | Any] = Field(default=None, description="callback to be executed after each step of the agent execution")
 
     # llm settings cascaded to the LLM model
-    llm: str | InstanceOf[LLM] | Any = Field(default=None)
-    function_calling_llm: str | InstanceOf[LLM] | Any = Field(default=None)
+    llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
+    function_calling_llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
     respect_context_window: bool = Field(default=True,description="Keep messages under the context window size by summarizing content")
     max_tokens: Optional[int] = Field(default=None, description="max. number of tokens for the agent's execution")
     max_execution_time: Optional[int] = Field(default=None, description="max. execution time for an agent to execute a task")
@@ -119,16 +120,11 @@ class Agent(BaseModel):
     response_template: Optional[str] = Field(default=None, description="Response format for the agent.")
 
     # config, cache, error handling
-    config: Optional[Dict[str, Any]] = Field(default=None, exclude=True, description="Configuration for the agent")
     formatting_errors: int = Field(default=0, description="Number of formatting errors.")
     agent_ops_agent_name: str = None
     agent_ops_agent_id: str = None
 
 
-    def __repr__(self):
-        return f"Agent(role={self.role}, goal={self.goal}, backstory={self.backstory})"
-
-
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -141,7 +137,7 @@ class Agent(BaseModel):
         required_fields = ["role", "goal"]
         for field in required_fields:
             if getattr(self, field) is None:
-                raise ValueError( f"{field} must be provided either directly or through config")
+                raise ValueError(f"{field} must be provided either directly or through config")
         return self
 
 
@@ -154,109 +150,84 @@ class Agent(BaseModel):
         """
 
         self.agent_ops_agent_name = self.role
-        unaccepted_attributes = ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION_NAME"]
-        callbacks = ([self.step_callback,]if self.step_callback is not None else [])
+        # unaccepted_attributes = ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION_NAME"]
 
         if isinstance(self.llm, LLM):
-            self.llm.timeout = self.max_execution_time
-            self.llm.max_tokens = self.max_tokens
-            self.llm.context_window_size = (self.llm.get_context_window_size() if self.respect_context_window == True else DEFAULT_CONTEXT_WINDOW)
-            self.llm.callbacks = callbacks
+            llm = self._set_llm_params(self.llm)
+            self.llm = llm
 
         elif isinstance(self.llm, str) or self.llm is None:
-            model_name = os.environ.get("LITELLM_MODEL_NAME", os.environ.get("MODEL", "gpt-3.5-turbo"))
-            llm_params = {
-                "model": model_name if self.llm is None else self.llm,
-                "timeout": self.max_execution_time,
-                "max_tokens": self.max_tokens,
-                "callbacks": callbacks,
-                "api_key": os.environ.get("LITELLM_API_KEY", None),
-                "base_url": os.environ.get("OPENAI_API_BASE", os.environ.get("OPENAI_BASE_URL", None))
-            }
-
-            set_provider = model_name.split("/")[0] if "/" in model_name else "openai" #! REFINEME
-            for provider, env_vars in LLM_VARS.items():
-                if provider == set_provider:
-                    for env_var in env_vars:
-                        key_name = env_var.get("key_name")
-
-                        if key_name and key_name not in unaccepted_attributes:
-                            env_value = os.environ.get(key_name)
-                            if env_value:
-                                key_name = ("api_key" if "API_KEY" in key_name else key_name)
-                                key_name = ("api_base" if "API_BASE" in key_name else key_name)
-                                key_name = ("api_version" if "API_VERSION" in key_name else key_name)
-                                llm_params[key_name] = env_value
-                        elif env_var.get("default", False):
-                            for key, value in env_var.items():
-                                if key not in ["prompt", "key_name", "default"]:
-                                    if key in os.environ:
-                                        llm_params[key] = value
-            self.llm = LLM(**llm_params)
-            context_window_size = (self.llm.get_context_window_size() if self.respect_context_window == True else DEFAULT_CONTEXT_WINDOW)
-            self.llm.context_window_size = context_window_size
+            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:
-            llm_params = {
-                "model": (getattr(self.llm, "model_name") or getattr(self.llm, "deployment_name") or str(self.llm)),
-                "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") or callbacks,
-                "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),
-                "organization": getattr(self.llm, "organization", None),
-            }
-            llm_params = {  k: v for k, v in llm_params.items() if v is not None }
-            self.llm = LLM(**llm_params)
+            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. For the sake of convenience, use the same metrics as the base LLM settings.
+        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):
-                self.function_calling_llm.timeout = self.max_execution_time
-                self.function_calling_llm.max_tokens = self.max_tokens
-                self.function_calling_llm.callbacks = callbacks
-                context_window_size = (
-                    self.function_calling_llm.get_context_window_size()
-                    if self.respect_context_window == True
-                    else DEFAULT_CONTEXT_WINDOW
-                )
-                self.function_calling_llm.context_window_size = context_window_size
+                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):
-                self.function_calling_llm = LLM(
-                    model=self.function_calling_llm,
-                    timeout=self.max_execution_time,
-                    max_tokens=self.max_tokens,
-                    callbacks=callbacks,
-                )
-                context_window_size = (
-                    self.function_calling_llm.get_context_window_size()
-                    if self.respect_context_window == True
-                    else DEFAULT_CONTEXT_WINDOW
-                )
-                self.function_calling_llm.context_window_size = context_window_size
+                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:
-                model_name = getattr(
-                    self.function_calling_llm,
-                    "model_name",
-                    getattr(
-                        self.function_calling_llm,
-                        "deployment_name",
-                        str(self.function_calling_llm),
-                    ),
-                )
-                if model_name is not None or model_name != "":
-                    self.function_calling_llm = LLM(
-                        model=model_name,
-                        timeout=self.max_execution_time,
-                        max_tokens=self.max_tokens,
-                        callbacks=callbacks,
-                    )
+                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
 
 
@@ -315,7 +286,32 @@ class Agent(BaseModel):
         return self
 
 
-    def invoke(self, prompts: str, output_formats: List[TaskOutputFormat], response_fields: List[ResponseField], **kwargs) -> Dict[str, Any]:
+    def _set_llm_params(self, llm: LLM, kwargs: Dict[str, Any] = None) -> LLM:
+        """
+        After setting up an LLM instance, add params to the instance.
+        Prioritize the agent's settings over the model's base setups.
+        """
+
+        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 self.step_callback is not None:
+            llm.callbacks = [self.step_callback, ]
+            llm._set_callbacks(llm.callbacks)
+
+        if self.respect_context_window == False:
+            llm.context_window_size = DEFAULT_CONTEXT_WINDOW_SIZE
+
+        if kwargs:
+            for k, v in kwargs.items():
+                try:
+                    setattr(llm, k, v)
+                except:
+                    pass
+        return llm
+
+
+    def invoke(self, prompts: str, output_formats: List[str | TaskOutputFormat], response_fields: List[ResponseField]) -> Dict[str, Any]:
         """
         Receive the system prompt in string and create formatted prompts using the system prompt and the agent's backstory.
         Then call the base model.
@@ -329,22 +325,13 @@ class Agent(BaseModel):
         messages.append({"role": "assistant", "content": self.backstory})
         self._logger.log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
 
-        callbacks = kwargs.get("callbacks", None)
-
-        raw_response = self.llm.call(
-            messages=messages, output_formats=output_formats, field_list=response_fields, callbacks=callbacks
-        )
+        raw_response = self.llm.call(messages=messages, output_formats=output_formats, field_list=response_fields)
         task_execution_counter += 1
         self._logger.log(level="info", message=f"Agent's first response in {type(raw_response).__name__}: {raw_response}", color="blue")
 
         if (raw_response is None or raw_response == "") and task_execution_counter < self.max_retry_limit:
             while task_execution_counter <= self.max_retry_limit:
-                raw_response = self.llm.call(
-                    messages=messages,
-                    output_formats=output_formats,
-                    field_list=response_fields,
-                    callbacks=callbacks,
-                )
+                raw_response = self.llm.call(messages=messages, output_formats=output_formats, field_list=response_fields)
                 task_execution_counter += 1
                 self._logger.log(level="info", message=f"Agent's next response in {type(raw_response).__name__}: {raw_response}", color="blue")
 
@@ -411,3 +398,7 @@ class Agent(BaseModel):
             self._rpm_controller.stop_rpm_counter()
 
         return raw_response
+
+
+    def __repr__(self):
+        return f"Agent(role={self.role}, goal={self.goal}, backstory={self.backstory})"

versionhq/llm/{llm_vars.py → llm_variables.py}

@@ -1,3 +1,93 @@
+JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
+
+
+"""
+List of models available on the framework.
+Model names align with the LiteLLM's key names defined in the JSON URL.
+Provider names align with the custom provider or model provider names.
+-> model_key = custom_provider_name/model_name
+"""
+
+MODELS = {
+    "openai": [
+        "gpt-3.5-turbo",
+        "gpt-4",
+        "gpt-4o",
+        "gpt-4o-mini",
+        "o1-mini",
+        "o1-preview",
+    ],
+    "gemini": [
+        "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",
+    ],
+    "anthropic": [
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-sonnet-20240620",
+        "claude-3-sonnet-20240229",
+        "claude-3-opus-20240229",
+        "claude-3-haiku-20240307",
+    ],
+    "ollama": [
+      "ollama/llama3.1",
+      "ollama/mixtral",
+    ],
+    # "watson": [
+    #     "watsonx/meta-llama/llama-3-1-70b-instruct",
+    #     "watsonx/meta-llama/llama-3-1-8b-instruct",
+    #     "watsonx/meta-llama/llama-3-2-11b-vision-instruct",
+    #     "watsonx/meta-llama/llama-3-2-1b-instruct",
+    #     "watsonx/meta-llama/llama-3-2-90b-vision-instruct",
+    #     "watsonx/meta-llama/llama-3-405b-instruct",
+    #     "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",
+    # ],
+}
+
+
+PROVIDERS = [
+    "openai",
+    "anthropic",
+    "gemini",
+    "ollama",
+    "watson",
+    "bedrock",
+    "azure",
+    "cerebras",
+    "llama",
+]
+
+
+"""
+Max input token size by the model.
+"""
 LLM_CONTEXT_WINDOW_SIZES = {
     "gpt-3.5-turbo": 8192,
     "gpt-4": 8192,
@@ -6,6 +96,19 @@ LLM_CONTEXT_WINDOW_SIZES = {
     "gpt-4-turbo": 128000,
     "o1-preview": 128000,
     "o1-mini": 128000,
+
+    "gemini/gemini-1.5-flash": 1048576,
+    "gemini/gemini-1.5-pro": 2097152,
+    "gemini/gemini-2.0-flash-exp": 1048576,
+    "gemini/gemini-gemma-2-9b-it": 8192,
+    "gemini/gemini-gemma-2-27b-it": 8192,
+
+    "claude-3-5-sonnet-20241022": 200000,
+    "claude-3-5-sonnet-20240620": 200000,
+    "claude-3-sonnet-20240229": 200000,
+    "claude-3-opus-20240229": 200000,
+    "claude-3-haiku-20240307": 200000,
+
     "deepseek-chat": 128000,
     "gemma2-9b-it": 8192,
     "gemma-7b-it": 8192,
@@ -20,8 +123,21 @@ LLM_CONTEXT_WINDOW_SIZES = {
     "llama3-70b-8192": 8192,
     "llama3-8b-8192": 8192,
     "mixtral-8x7b-32768": 32768,
+    "claude-3-5-sonnet-2024102": 200000,
+}
+
+
+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",
+    "anthropic": "ANTHROPIC_API_BASE",
+    "gemini": "GEMINI_API_BASE",
+}
 
 LLM_VARS = {
     "openai": [
@@ -107,67 +223,39 @@ LLM_VARS = {
 }
 
 
-PROVIDERS = [
-    "openai",
-    "anthropic",
-    "gemini",
-    "ollama",
-    "watson",
-    "bedrock",
-    "azure",
-    "cerebras",
-    "llama",
-]
 
-MODELS = {
-    "openai": ["gpt-4", "gpt-4o", "gpt-4o-mini", "o1-mini", "o1-preview"],
-    "anthropic": [
-        "claude-3-5-sonnet-20240620",
-        "claude-3-sonnet-20240229",
-        "claude-3-opus-20240229",
-        "claude-3-haiku-20240307",
-    ],
-    "gemini": [
-        "gemini/gemini-1.5-flash",
-        "gemini/gemini-1.5-pro",
-        "gemini/gemini-gemma-2-9b-it",
-        "gemini/gemini-gemma-2-27b-it",
-    ],
-    "ollama": ["ollama/llama3.1", "ollama/mixtral"],
-    "watson": [
-        "watsonx/meta-llama/llama-3-1-70b-instruct",
-        "watsonx/meta-llama/llama-3-1-8b-instruct",
-        "watsonx/meta-llama/llama-3-2-11b-vision-instruct",
-        "watsonx/meta-llama/llama-3-2-1b-instruct",
-        "watsonx/meta-llama/llama-3-2-90b-vision-instruct",
-        "watsonx/meta-llama/llama-3-405b-instruct",
-        "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",
-    ],
-}
+"""
+Params for litellm.completion() func
+"""
 
-JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
+LITELLM_COMPLETION_KEYS = [
+    "model",
+    "messages",
+    "timeout",
+    "temperature", "top_p",
+    "n",
+    "stream"
+    "stream_options"
+    "stop",
+    "max_compl,etion_tokens"
+    "max_tokens",
+    "modalities",
+    "prediction",
+    "audio",
+    "presen,ce_penalty"
+    "frequency_penalty,"
+    "logit_bias",
+    "user",
+    "response_format",
+    "seed",
+    "tools,"
+    "tool_choice"
+    "logprobs",
+    "top_logpr,obs"
+    "parallel_tool_calls"
+    "extra_headers",
+    "base_url",
+    "api_versi,on"
+    "api_key",
+    "model_list"
+]

versionhq/llm/model.py

@@ -4,20 +4,26 @@ import sys
 import threading
 import warnings
 import litellm
+from abc import ABC
 from dotenv import load_dotenv
 from litellm import get_supported_openai_params
 from contextlib import contextmanager
 from typing import Any, Dict, List, Optional
+from typing_extensions import Self
 
-from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES
+from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf, ConfigDict
+from pydantic_core import PydanticCustomError
+
+from versionhq.llm.llm_variables import LLM_CONTEXT_WINDOW_SIZES, LLM_API_KEY_NAMES, LLM_BASE_URL_KEY_NAMES, MODELS, LITELLM_COMPLETION_KEYS
 from versionhq.task import TaskOutputFormat
 from versionhq.task.model import ResponseField
+from versionhq._utils.logger import Logger
+
 
 load_dotenv(override=True)
 API_KEY_LITELLM = os.environ.get("API_KEY_LITELLM")
-DEFAULT_CONTEXT_WINDOW = int(8192 * 0.75)
-os.environ["LITELLM_LOG"] = "DEBUG"
-
+DEFAULT_CONTEXT_WINDOW_SIZE = int(8192 * 0.75)
+DEFAULT_MODEL_NAME = os.environ.get("DEFAULT_MODEL_NAME")
 
 class FilteredStream:
     def __init__(self, original_stream):
@@ -94,146 +100,175 @@ class LLMResponseSchema:
         return response_schema
 
 
-class LLM:
+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.
-    (Memo) Response formats will be given at the Task handling.
+    Some optional params are passed by the agent, else follow the default settings of the model provider.
     """
 
-    def __init__(
-        self,
-        model: str,
-        timeout: Optional[float | int] = None,
-        max_tokens: Optional[int] = None,
-        max_completion_tokens: Optional[int] = None,
-        context_window_size: Optional[int] = DEFAULT_CONTEXT_WINDOW,
-        callbacks: List[Any] = [],
-        temperature: Optional[float] = None,
-        top_p: Optional[float] = None,
-        n: Optional[int] = None,
-        stop: Optional[str | List[str]] = None,
-        presence_penalty: Optional[float] = None,
-        frequency_penalty: Optional[float] = None,
-        logit_bias: Optional[Dict[int, float]] = None,
-        # response_format: Optional[Dict[str, Any]] = None,
-        seed: Optional[int] = None,
-        logprobs: Optional[bool] = None,
-        top_logprobs: Optional[int] = None,
-        base_url: Optional[str] = None,
-        api_version: Optional[str] = None,
-        api_key: Optional[str] = None,
-        **kwargs,
-    ):
-        self.model = model
-        self.timeout = timeout
-        self.max_tokens = max_tokens
-        self.max_completion_tokens = max_completion_tokens
-        self.context_window_size = context_window_size
-        self.callbacks = callbacks
-
-        self.temperature = temperature
-        self.top_p = top_p
-        self.n = n
-        self.stop = stop
-        self.presence_penalty = presence_penalty
-        self.frequency_penalty = frequency_penalty
-        self.logit_bias = logit_bias
-        # self.response_format = response_format
-        self.seed = seed
-        self.logprobs = logprobs
-        self.top_logprobs = top_logprobs
-
-        self.base_url = base_url
-        self.api_version = api_version
-        self.api_key = api_key if api_key else API_KEY_LITELLM
-
-        self.kwargs = kwargs
-
-        litellm.drop_params = True
-        litellm.set_verbose=True
-        self.set_callbacks(callbacks)
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
+    _init_model_name: str = PrivateAttr(default=None)
+    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="litellm's api base")
+    api_key: Optional[str] = Field(default=None)
+    api_version: Optional[str] = Field(default=None)
+
+    # optional params
+    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)
+    stop: Optional[str | List[str]] = Field(default=None)
+    presence_penalty: Optional[float] = Field(default=None)
+    frequency_penalty: Optional[float] = Field(default=None)
+    logit_bias: Optional[Dict[int, float]] = Field(default=None)
+    seed: Optional[int] = Field(default=None)
+    logprobs: Optional[bool] = Field(default=None)
+    top_logprobs: Optional[int] = Field(default=None)
+
+    litellm.drop_params = True
+    litellm.set_verbose = True
+    os.environ['LITELLM_LOG'] = 'DEBUG'
+
+
+    @model_validator(mode="after")
+    def validate_base_params(self) -> Self:
+        """
+        1. Model name and provider
+        Check the provided model name in the list and update it with the valid model key name.
+        Then add the model provider if it is not provided.
+        Assign a default model and provider when we cannot find a model key.
+
+        2.  Set up other base parameters for the model and LiteLLM as below:
+        1. LiteLLM - drop_params, set_verbose, callbacks
+        2. Model setup - context_window_size, api_key, base_url
+        """
+
+        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
+        self.model = None
+
+        if self.provider and MODELS.get(self.provider) is not None:
+            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="info", 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
+                    # raise PydanticCustomError("invalid_model", "The provided model is not in the list.", {})
+
+        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="info", message=f"The provided model \'{self.model}\' is not in the list. We'll assign a default model.", color="yellow")
+                self.model = DEFAULT_MODEL_NAME
+                self.provider = "openai"
+                # raise PydanticCustomError("invalid_model", "The provided model is not in the list.", {})
+
+        if self.callbacks is not None:
+            self._set_callbacks(self.callbacks)
+
+        self.context_window_size = self._get_context_window_size()
+
+        api_key_name = LLM_API_KEY_NAMES.get(self.provider, "LITELLM_API_KEY")
+        self.api_key = os.environ.get(api_key_name, None)
+
+        base_url_key_name = LLM_BASE_URL_KEY_NAMES.get(self.provider, "OPENAI_API_BASE")
+        self.base_url = os.environ.get(base_url_key_name, None)
+
+        return self
+
 
     def call(
         self,
-        output_formats: List[TaskOutputFormat],
+        output_formats: List[str | TaskOutputFormat],
         field_list: Optional[List[ResponseField]],
         messages: List[Dict[str, str]],
-        callbacks: List[Any] = [],
+        **kwargs,
+        # callbacks: List[Any] = [],
     ) -> str:
         """
-        Execute LLM based on Agent's controls.
+        Execute LLM based on the agent's params and model params.
         """
 
         with suppress_warnings():
-            if callbacks and len(callbacks) > 0:
-                self.set_callbacks(callbacks)
+            if len(self.callbacks) > 0:
+                self._set_callbacks(self.callbacks)
 
             try:
-                response_format = None
-
-                #! REFINEME
-                if TaskOutputFormat.JSON in output_formats:
-                    response_format = LLMResponseSchema(
-                        response_type="json_object", field_list=field_list
-                    )
-
-                params = {
-                    "model": self.model,
-                    "messages": messages,
-                    "timeout": self.timeout,
-                    "temperature": self.temperature,
-                    "top_p": self.top_p,
-                    "n": self.n,
-                    "stop": self.stop,
-                    "max_tokens": self.max_tokens or self.max_completion_tokens,
-                    "presence_penalty": self.presence_penalty,
-                    "frequency_penalty": self.frequency_penalty,
-                    "logit_bias": self.logit_bias,
-                    # "response_format": response_format,
-                    "seed": self.seed,
-                    "logprobs": self.logprobs,
-                    "top_logprobs": self.top_logprobs,
-                    "api_base": self.base_url,
-                    "api_version": self.api_version,
-                    "api_key": self.api_key,
-                    "stream": False,
-                    **self.kwargs,
-                }
-                params = {k: v for k, v in params.items() if v is not None}
-                res = litellm.completion(**params)
+                # response_format = None
+                # #! REFINEME
+                # if TaskOutputFormat.JSON in output_formats:
+                #     response_format = LLMResponseSchema(
+                #         response_type="json_object", field_list=field_list
+                #     )
+
+                params = {}
+                for item in LITELLM_COMPLETION_KEYS:
+                    if hasattr(self, item) and getattr(self, item) is not None:
+                        params[item] = getattr(self, item)
+
+                res = litellm.completion(messages=messages, stream=False, **params)
                 return res["choices"][0]["message"]["content"]
 
             except Exception as e:
-                logging.error(f"LiteLLM call failed: {str(e)}")
+                self._logger.log(level="error", message=f"LiteLLM call failed: {str(e)}", color="red")
                 return None
 
-    def supports_function_calling(self) -> bool:
+
+    def _supports_function_calling(self) -> bool:
         try:
             params = get_supported_openai_params(model=self.model)
             return "response_format" in params
         except Exception as e:
-            logging.error(f"Failed to get supported params: {str(e)}")
+            self._logger.log(level="error", message=f"Failed to get supported params: {str(e)}", color="red")
             return False
 
-    def supports_stop_words(self) -> bool:
+
+    def _supports_stop_words(self) -> bool:
         try:
             params = get_supported_openai_params(model=self.model)
             return "stop" in params
         except Exception as e:
-            logging.error(f"Failed to get supported params: {str(e)}")
+            self._logger.log(level="error", message=f"Failed to get supported params: {str(e)}", color="red")
             return False
 
-    def get_context_window_size(self) -> int:
+
+    def _get_context_window_size(self) -> int:
         """
         Only use 75% of the context window size to avoid cutting the message in the middle.
         """
-        return (
-            int(LLM_CONTEXT_WINDOW_SIZES.get(self.model) * 0.75)
-            if hasattr(LLM_CONTEXT_WINDOW_SIZES, self.model)
-            else DEFAULT_CONTEXT_WINDOW
-        )
+        return int(LLM_CONTEXT_WINDOW_SIZES.get(self.model) * 0.75) if LLM_CONTEXT_WINDOW_SIZES.get(self.model) is not None else DEFAULT_CONTEXT_WINDOW_SIZE
+
 
-    def set_callbacks(self, callbacks: List[Any]):
+    def _set_callbacks(self, callbacks: List[Any]):
         callback_types = [type(callback) for callback in callbacks]
         for callback in litellm.success_callback[:]:
             if type(callback) in callback_types:

versionhq/task/__init__.py

@@ -5,5 +5,5 @@ class TaskOutputFormat(str, Enum):
     """Enum that represents the output format of a task."""
 
     JSON = "json"
-    PYDANTIC = "pydantic"
+    PYDANTIC = "pydantic model"
     RAW = "raw"

versionhq/task/model.py

@@ -117,7 +117,7 @@ class Task(BaseModel):
     _original_description: str = PrivateAttr(default=None)
     _logger: Logger = PrivateAttr()
     _task_output_handler = TaskOutputStorageHandler()
-    config: Optional[Dict[str, Any]] = Field(default=None, description="configuration for the agent")
+    config: Optional[Dict[str, Any]] = Field(default=None, description="values to set on Task class")
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="unique identifier for the object, not set by user")
     name: Optional[str] = Field(default=None)
@@ -245,7 +245,7 @@ class Task(BaseModel):
         output_json_dict: Dict[str, Any] = dict()
 
         try:
-            raw_result = raw_result.replace("{'", '{"').replace("{ '", '{"').replace("': '", '": "').replace("'}", '"}').replace("' }", '"}').replace("', '", '", "').replace("['", '["').replace("[ '", '[ "').replace("']", '"]').replace("' ]", '" ]')
+            raw_result = raw_result.replace("{'", '{"').replace("{ '", '{"').replace("': '", '": "').replace("'}", '"}').replace("' }", '"}').replace("', '", '", "').replace("['", '["').replace("[ '", '[ "').replace("']", '"]').replace("' ]", '" ]').replace("{\n'", '{"').replace("{\'", '{"')
             r = json.dumps(eval(str(raw_result)))
             output_json_dict = json.loads(r)
 
@@ -425,23 +425,23 @@ class Task(BaseModel):
             output_formats_to_follow[item.title] = f"<Return your answer in {item.type.__name__}>"
 
         output_prompt = f"""
-Output only valid JSON conforming to the specified format. Use double quotes for keys and values:
-{output_formats_to_follow}
+Output only valid JSON conforming to the specified format. Use double quotes for all keys and string values. Do not use single quotes, trailing commas, or other non-standard JSON syntax.
+Specified format: {output_formats_to_follow}
         """
         return output_prompt
 
 
     @property
-    def expected_output_formats(self) -> List[TaskOutputFormat]:
+    def expected_output_formats(self) -> List[str | TaskOutputFormat]:
         """
         Return output formats in list with the ENUM item.
         `TaskOutputFormat.RAW` is set as default.
         """
-        outputs = [TaskOutputFormat.RAW,]
+        outputs = [TaskOutputFormat.RAW.value,]
         if self.expected_output_json:
-            outputs.append(TaskOutputFormat.JSON)
+            outputs.append(TaskOutputFormat.JSON.value)
         if self.expected_output_pydantic:
-            outputs.append(TaskOutputFormat.PYDANTIC)
+            outputs.append(TaskOutputFormat.PYDANTIC.value)
         return outputs
 
 

versionhq/team/team_planner.py

@@ -17,7 +17,7 @@ class TeamPlanner:
 
     def __init__(self, tasks: List[Task], planner_llm: Optional[Any] = None):
         self.tasks = tasks
-        self.planner_llm = planner_llm if planner_llm else os.environ.get("LITELLM_MODEL_NAME")
+        self.planner_llm = planner_llm if planner_llm else os.environ.get("DEFAULT_MODEL_NAME")
 
 
     def _handle_assign_agents(self, unassigned_tasks: List[Task]) -> List[Any]:

{versionhq-1.1.9.12.dist-info → versionhq-1.1.9.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.1.9.12
+Version: 1.1.9.14
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -60,7 +60,7 @@ Requires-Dist: composio-langchain>=0.6.12
 
 ![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.9.3-blue)
+![PyPI](https://img.shields.io/badge/PyPI->=v1.1.9-blue)
 ![python ver](https://img.shields.io/badge/Python-3.12/3.13-purple)
 ![pyenv ver](https://img.shields.io/badge/pyenv-2.5.0-orange)
 

{versionhq-1.1.9.12.dist-info → versionhq-1.1.9.14.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=gNhQnm2MOmarmLsrzYdwPBjYMPPFysDn5XEStGEqjAY,951
+versionhq/__init__.py,sha256=qgKbO4z_Ip_tf_CLeRokSCc3tyh4akIzfNyL5-yb7HM,951
 versionhq/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/_utils/cache_handler.py,sha256=3-lw_5ZMWC8hnPAkSQULJ2V1FvZZ-wg9mQaUJGSOjI8,403
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
@@ -7,7 +7,7 @@ versionhq/_utils/process_config.py,sha256=UqoWD5IR4VLxEDGxIyVUylw_ppXwk8Wx1ynVuD
 versionhq/_utils/rpm_controller.py,sha256=dUgFd6JtdjiLLTRmrjsBHdTaLn73XFuKpLbJh7thf2A,2289
 versionhq/_utils/usage_metrics.py,sha256=hhq1OCW8Z4V93vwW2O2j528EyjOlF8wlTsX5IL-7asA,1106
 versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent/model.py,sha256=LFkD00zIeIfntwvebomYX6zTqIMQVkQYFEKjxOtTaPQ,18598
+versionhq/agent/model.py,sha256=_7mq06b1I7kRe7XYyPKPjzduBuBBFDa_CvmEr3WkKpc,18138
 versionhq/agent/parser.py,sha256=Z_swUPO3piJQuYU8oVYwXWeR2zjmNb4PxbXZeR-GlIg,4694
 versionhq/agent/TEMPLATES/Backstory.py,sha256=cdngBx1GEv7nroR46FEhnysnBJ9mEVL763_9np6Skkc,395
 versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -20,24 +20,24 @@ versionhq/clients/product/model.py,sha256=c_watpIg-FzpJ2tMml6M1EbAckgGZOqTSc_GZ3
 versionhq/clients/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/workflow/model.py,sha256=Onu3O4y_wroOnEPf7QZkeZp_WPHfk2DVQGdtoXfZvbc,5984
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/llm/llm_vars.py,sha256=YZoXqFBW7XpclUZ14_AAz7WOjoyCXnGcI959GSpX2q0,5343
-versionhq/llm/model.py,sha256=mXzSuf1s6MebGT7_yqgNppde0NIlAF8bjIXAp2MZ9Uw,8247
+versionhq/llm/llm_variables.py,sha256=2cRRgUyJ9Em2k0NcEWivsDAoDhH04T3pN_hG6IzEBCQ,7177
+versionhq/llm/model.py,sha256=DNvg93t55VujCqFSvTbjEVgPdTZTwG8CIQWre9YHH_o,10825
 versionhq/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/storage/task_output_storage.py,sha256=xoBJHeqUyQt6iJoR1WQTghP-fyxXL66qslpX1QC2-4o,4827
-versionhq/task/__init__.py,sha256=g4mCATnn1mUXxsfQ5p6IpPawr8O421wVIT8kMKEcxQw,180
+versionhq/task/__init__.py,sha256=l2r_g01i91JAGlOoHZP_Gh2WCk6mo9D19lcqt7sKMpQ,186
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
 versionhq/task/log_handler.py,sha256=KJRrcNZgFSKhlNzvtYFnvtp6xukaF1s7ifX9u4zWrN8,1683
-versionhq/task/model.py,sha256=LYnOSElBNgySQEqFlZfRP-bFF9zkbXnQgvFtDSJTwZY,19555
+versionhq/task/model.py,sha256=xyDr9AS7Xp1jYlABMuqD7Cm1RfHnfNL5rEzyE47YUFI,19729
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/team/model.py,sha256=E52OUVzUtvR--51SFRJos3JdYKri1t2jbvvzoOvShQc,20181
-versionhq/team/team_planner.py,sha256=uzX2yed7A7gNSs6qH5jIq2zXMVF5BwQQ4HPATsB9DSQ,3675
+versionhq/team/team_planner.py,sha256=gUmrW_AZYQqAkOylS2XHuYIdTy92-E7CxQB5VmxqgrE,3675
 versionhq/tool/__init__.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtgpqOzKZQ,1843
 versionhq/tool/composio_tool.py,sha256=BJqaA1NhV0BT9AdY7OLCGpsAI3VEuCKnOS6D9vuU4zQ,8630
 versionhq/tool/decorator.py,sha256=W_WjzZy8y43AoiFjHLPUQfNipmpOPe-wQknCWloPwmY,1195
 versionhq/tool/model.py,sha256=yrvog9wh-cuIXRngwXOzPlHwBO3UhUFxCH3vQ5qRKBA,6823
 versionhq/tool/tool_handler.py,sha256=A3zUkZkx4JEpFHI2uBkHDpzWfADw-bCYUQhgm6rpITM,1569
-versionhq-1.1.9.12.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
-versionhq-1.1.9.12.dist-info/METADATA,sha256=RvuJoyBRmf3lQjdxix0QFCgYjur1CpUJCUs3dZaJlz0,16071
-versionhq-1.1.9.12.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.1.9.12.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.1.9.12.dist-info/RECORD,,
+versionhq-1.1.9.14.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
+versionhq-1.1.9.14.dist-info/METADATA,sha256=NnSKnOPGCFgFxyg1-tUjDbe08zfGM8VLfnWqrnOc7KA,16071
+versionhq-1.1.9.14.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.1.9.14.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.9.14.dist-info/RECORD,,