versionhq 1.1.9.14__py3-none-any.whl → 1.1.10.3__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.14"
+__version__ = "1.1.10.3"
 __all__ = [
     "Agent",
     "Customer",

versionhq/_utils/logger.py

@@ -12,8 +12,6 @@ class Printer:
             self._print_red(content)
         elif color == "green":
             self._print_green(content)
-        elif color == "purple":
-            self._print_purple(content)
         elif color == "blue":
             self._print_blue(content)
         elif color == "yellow":
@@ -27,9 +25,6 @@ class Printer:
     def _print_green(self, content):
         print("\033[1m\033[92m {}\033[00m".format(content))
 
-    def _print_purple(self, content):
-        print("\033[95m {}\033[00m".format(content))
-
     def _print_red(self, content):
         print("\033[91m {}\033[00m".format(content))
 
@@ -47,4 +42,4 @@ class Logger(BaseModel):
     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}][{level.upper()}]: {message}", color=color)
+            self._printer.print(f"\n{timestamp} - versionHQ - {level.upper()}: {message}", color=color)

versionhq/_utils/process_config.py

@@ -8,19 +8,16 @@ def process_config(values_to_update: Dict[str, Any], model_class: Type[BaseModel
     Refer to the Pydantic model class for field validation.
     """
 
-    if hasattr(values_to_update, "config"):
-        config = values_to_update.pop("config", {})
-    else:
-        return values_to_update
+    config = values_to_update.pop("config", {})
 
+    if config:
+        for k, v in config.items():
+            if k not in model_class.model_fields or values_to_update.get(k) is not None:
+                continue
 
-    for key, value in config.items():
-        if key not in model_class.model_fields or values_to_update.get(key) is not None:
-            continue
-
-        if isinstance(value, dict) and isinstance(values_to_update.get(key), dict):
-            values_to_update[key].update(value)
-        else:
-            values_to_update[key] = value
+            if isinstance(v, dict) and isinstance(values_to_update.get(k), dict):
+                values_to_update[k].update(v)
+            else:
+                values_to_update[k] = v
 
     return values_to_update

versionhq/agent/TEMPLATES/Backstory.py

@@ -1,3 +1,4 @@
-BACKSTORY="""You are a {role} with deep understanding of {knowledge} and highly skilled in {skillsets}.
-You have access to call the RAG tools that can {rag_tool_overview}. By leveraging these tools, your knowledge, and skillsets, you can identify competitive strategies that have been proven effective to achieve the goal: {goal}. Take these into consideration, create innovative solutions.
-"""
+BACKSTORY_FULL="""You are an expert {role} with deep understanding of {knowledge} and highly skilled in {skillsets}. You have abilities to call the RAG tools that can {rag_tool_overview}. Your primary goal is to identify competitive solutions by leveraging your knowledge and skillsets to achieve the following goal: {goal}."""
+
+
+BACKSTORY_SHORT="""You are an expert {role} with the right skillsets and knowledge. Your primary goal is to identify competitive solutions by leveraging your knowledge and skillsets to achieve the following goal: {goal}."""

versionhq/agent/model.py

@@ -1,19 +1,20 @@
 import os
 import uuid
-from typing import Any, Dict, List, Optional, TypeVar, Callable
+from typing import Any, Dict, List, Optional, TypeVar, Callable, Type
 from typing_extensions import Self
 from dotenv import load_dotenv
-from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator
+import litellm
+
+from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator, ConfigDict
 from pydantic_core import PydanticCustomError
 
+from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW_SIZE, DEFAULT_MODEL_NAME
+from versionhq.tool.model import Tool, ToolSet
 from versionhq._utils.logger import Logger
 from versionhq._utils.rpm_controller import RPMController
 from versionhq._utils.usage_metrics import UsageMetrics
-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
+from versionhq._utils.process_config import process_config
+
 
 load_dotenv(override=True)
 T = TypeVar("T", bound="Agent")
@@ -92,18 +93,22 @@ class Agent(BaseModel):
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     role: str = Field(description="role of the agent - used in summary and logs")
     goal: str = Field(description="concise goal of the agent (details are set in the Task instance)")
-    backstory: Optional[str] = Field(default=None, description="system context passed to the LLM")
+    backstory: Optional[str] = Field(default=None, description="developer prompt to the llm")
     knowledge: Optional[str] = Field(default=None, description="external knowledge fed to the agent")
     skillsets: Optional[List[str]] = Field(default_factory=list)
-    tools: Optional[List[Tool | Any]] = Field(default_factory=list)
+    tools: Optional[List[Tool | ToolSet | Type[Tool]]] = Field(default_factory=list)
 
-    # team, task execution rules
+    # prompting
+    use_developer_prompt: Optional[bool] = Field(default=True, description="Use developer prompt when calling the llm")
+    developer_propmt_template: Optional[str] = Field(default=None, description="ddeveloper prompt template")
+    user_prompt_template: Optional[str] = Field(default=None, description="user prompt template")
+
+    # task execution rules
     team: Optional[List[Any]] = Field(default=None, description="Team to which the agent belongs")
-    allow_delegation: bool = Field(default=False,description="Enable agent to delegate and ask questions among each other")
-    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[Callable | Any] = Field(default=None, description="callback to be executed after each step of the agent execution")
+    allow_delegation: bool = Field(default=False,description="if the agent can delegate the task to another agent or ask some help")
+    max_retry_limit: int = Field(default=2 ,description="max. number of retry for the task execution when an error occurs")
+    maxit: Optional[int] = Field(default=25,description="max. number of total optimization loops conducted when an error occurs")
+    callbacks: Optional[List[Callable]] = Field(default_factory=list, description="callback functions to execute after any task execution")
 
     # llm settings cascaded to the LLM model
     llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
@@ -112,15 +117,10 @@ class Agent(BaseModel):
     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")
     max_rpm: Optional[int] = Field(default=None, description="max. number of requests per minute for the agent execution")
-
-    # prompt rules
-    use_system_prompt: Optional[bool] = Field(default=True, description="Use system prompt for the agent")
-    system_template: Optional[str] = Field(default=None, description="System format for the agent.")
-    prompt_template: Optional[str] = Field(default=None, description="Prompt format for the agent.")
-    response_template: Optional[str] = Field(default=None, description="Response format for the agent.")
+    llm_config: Optional[Dict[str, Any]] = Field(default=None, description="other llm config cascaded to the model")
 
     # config, cache, error handling
-    formatting_errors: int = Field(default=0, description="Number of formatting errors.")
+    formatting_errors: int = Field(default=0, description="number of formatting errors.")
     agent_ops_agent_name: str = None
     agent_ops_agent_id: str = None
 
@@ -132,6 +132,21 @@ class Agent(BaseModel):
             raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})
 
 
+    # @field_validator(mode="before")
+    # def set_up_from_config(cls) -> None:
+    #     if cls.config is not None:
+    #         try:
+    #             for k, v in cls.config.items():
+    #                 setattr(cls, k, v)
+    #         except:
+    #             pass
+
+    @model_validator(mode="before")
+    @classmethod
+    def process_model_config(cls, values: Dict[str, Any]) -> None:
+        return process_config(values_to_update=values, model_class=cls)
+
+
     @model_validator(mode="after")
     def validate_required_fields(self) -> Self:
         required_fields = ["role", "goal"]
@@ -145,7 +160,7 @@ class Agent(BaseModel):
     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`, `step_callback`,`respect_context_window` to 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.
         """
 
@@ -231,6 +246,34 @@ class Agent(BaseModel):
         return self
 
 
+    def _set_llm_params(self, llm: LLM, config: 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.callbacks:
+        #     llm.callbacks = self.callbacks
+        #     llm._set_callbacks(llm.callbacks)
+
+        if self.respect_context_window == False:
+            llm.context_window_size = DEFAULT_CONTEXT_WINDOW_SIZE
+
+        config = self.config.update(config) if self.config else config
+        if config:
+            valid_params = litellm.get_supported_openai_params(model=llm.model)
+            for k, v in config.items():
+                try:
+                    if k in valid_params and v is not None:
+                        setattr(llm, k, v)
+                except:
+                    pass
+        return llm
+
+
     @model_validator(mode="after")
     def set_up_tools(self) -> Self:
         """
@@ -241,25 +284,21 @@ class Agent(BaseModel):
 
         else:
             tool_list = []
-            def empty_func():
-                return "empty function"
 
             for item in self.tools:
                 if isinstance(item, Tool):
                     tool_list.append(item)
 
-                elif isinstance(item, dict):
-                    if "function" not in item:
-                       setattr(item, "function", empty_func)
+                elif isinstance(item, dict) and "func" in item:
                     tool = Tool(**item)
                     tool_list.append(tool)
 
-                elif isinstance(item, str):
-                    tool = Tool(name=item, function=empty_func)
-                    tool_list.append(tool)
+                elif type(item) is Tool and hasattr(item, "func"):
+                    tool_list.append(item)
 
                 else:
-                    tool_list.append(item) # address custom tool
+                    self._logger.log(level="error", message=f"Tool {str(item)} is missing a function.", color="red")
+                    raise PydanticCustomError("invalid_tool", f"The tool {str(item)} is missing a function.", {})
 
             self.tools = tool_list
 
@@ -273,108 +312,98 @@ class Agent(BaseModel):
         """
 
         if self.backstory is None:
-            from versionhq.agent.TEMPLATES.Backstory import BACKSTORY
-            backstory = BACKSTORY.format(
-                role=self.role,
-                knowledge=self.knowledge if isinstance(self.knowledge, str) else None,
-                skillsets=", ".join([item for item in self.skillsets]),
-                rag_tool_overview=", ".join([item.name for item in self.tools if hasattr(item, "name")]) if self.tools else "",
-                goal=self.goal,
-            )
+            from versionhq.agent.TEMPLATES.Backstory import BACKSTORY_FULL, BACKSTORY_SHORT
+            backstory = ""
+
+            if self.tools or self.knowledge or self.skillsets:
+                backstory = BACKSTORY_FULL.format(
+                    role=self.role,
+                    goal=self.goal,
+                    knowledge=self.knowledge if isinstance(self.knowledge, str) else None,
+                    skillsets=", ".join([item for item in self.skillsets]),
+                    rag_tool_overview=", ".join([item.name for item in self.tools if hasattr(item, "name")]) if self.tools else "",
+                )
+            else:
+                backstory = BACKSTORY_SHORT.format(role=self.role, goal=self.goal)
+
             self.backstory = backstory
 
         return self
 
 
-    def _set_llm_params(self, llm: LLM, kwargs: Dict[str, Any] = None) -> LLM:
+    def invoke(
+        self,
+        prompts: str,
+        response_format: Optional[Dict[str, Any]] = None,
+        tools: Optional[List[Tool | ToolSet | Type[Tool]]] = None,
+        tool_res_as_final: bool = False
+        ) -> Dict[str, Any]:
         """
-        After setting up an LLM instance, add params to the instance.
-        Prioritize the agent's settings over the model's base setups.
+        Create formatted prompts using the developer prompt and the agent's backstory, then call the base model.
+        - Execute the task up to `self.max_retry_limit` times in case of receiving an error or empty response.
+        - Pass the task_tools to the model to let them execute.
         """
 
-        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
+        task_execution_counter = 0
+        iterations = 0
+        raw_response = None
+        messages = []
 
-        if kwargs:
-            for k, v in kwargs.items():
-                try:
-                    setattr(llm, k, v)
-                except:
-                    pass
-        return llm
+        messages.append({"role": "user", "content": prompts})
+        if self.use_developer_prompt:
+            messages.append({"role": "system", "content": self.backstory})
+        self._logger.log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
 
+        try:
+            if tool_res_as_final is True:
+                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)
+                raw_response = func_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
+            else:
+                raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools)
 
-    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.
-        When encountering errors, we try the task execution up to `self.max_retry_limit` times.
-        """
+            task_execution_counter += 1
+            self._logger.log(level="info", message=f"Agent response: {raw_response}", color="blue")
 
-        task_execution_counter, raw_response = 0, None
+            if raw_response and self.callbacks:
+                for item in self.callbacks:
+                    raw_response = item(raw_response)
 
-        messages = []
-        messages.append({"role": "user", "content": prompts})  #! REFINEME
-        messages.append({"role": "assistant", "content": self.backstory})
-        self._logger.log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
+        except Exception as e:
+            self._logger.log(level="error", message=f"An error occured. The agent will retry: {str(e)}", color="red")
 
-        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")
+            while not raw_response and task_execution_counter < self.max_retry_limit:
+                while not raw_response and iterations < self.maxit:
+                    raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools)
+                    iterations += 1
 
-        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)
                 task_execution_counter += 1
-                self._logger.log(level="info", message=f"Agent's next response in {type(raw_response).__name__}: {raw_response}", color="blue")
+                self._logger.log(level="info", message=f"Agent #{task_execution_counter} response: {raw_response}", color="blue")
 
-        elif raw_response is None or raw_response == "":
-            self._logger.log(level="error", message="Received None or empty response from the model", color="red")
-            raise ValueError("Invalid response from LLM call - None or empty.")
+                if raw_response and self.callbacks:
+                    for item in self.callbacks:
+                        raw_response = item(raw_response)
+
+            if not raw_response:
+                self._logger.log(level="error", message="Received None or empty response from the model", color="red")
+                raise ValueError("Invalid response from LLM call - None or empty.")
 
         return raw_response
 
 
-    def execute_task(self, task, context: Optional[str] = None) -> str:
+    def execute_task(self, task, context: Optional[str] = None, task_tools: Optional[List[Tool | ToolSet]] = list()) -> str:
         """
         Execute the task and return the response in string.
         The agent utilizes the tools in task or their own tools if the task.can_use_agent_tools is True.
         The agent must consider the context to excute the task as well when it is given.
         """
+        from versionhq.task.model import Task
 
-        task_prompt = task.prompt()
-        if context is not task.prompt_context:  # as `task.prompt()` includes adding `task.prompt_context` to the prompt.
-            task_prompt += context
-
-        tool_results = []
-        if task.tools:
-            for item in task.tools:
-                if isinstance(item, ToolSet):
-                    tool_result = item.tool.run(**item.kwargs)
-                    tool_results.append(tool_result)
-                elif isinstance(item, Tool):
-                    tool_result = item.run()
-                    tool_results.append(tool_result)
-                else:
-                    try:
-                        item.run()
-                    except:
-                        pass
-
-        if task.can_use_agent_tools is True and self.tools:
-            for tool in self.tools:
-                tool_result = tool.run()
-                tool_results.append(tool_result)
+        task: InstanceOf[Task] = task
+        tools: Optional[List[Tool | ToolSet | Type[Tool]]] = task_tools + self.tools if task.can_use_agent_tools else task_tools
 
-        if task.take_tool_res_as_final:
-            return tool_results
+        task_prompt = task.prompt(model_provider=self.llm.provider)
+        if context is not task.prompt_context:
+            task_prompt += context
 
         # if self.team and self.team._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)
@@ -382,17 +411,22 @@ class Agent(BaseModel):
         #     task_prompt = self._use_trained_data(task_prompt=task_prompt)
 
         try:
+            self._times_executed += 1
             raw_response = self.invoke(
                 prompts=task_prompt,
-                output_formats=task.expected_output_formats,
-                response_fields=task.output_field_list,
+                response_format=task._structure_response_format(model_provider=self.llm.provider),
+                tools=tools,
+                tool_res_as_final=task.tool_res_as_final,
             )
 
         except Exception as e:
             self._times_executed += 1
+            self._logger.log(level="error", message=f"The agent failed to execute the task. Error: {str(e)}", color="red")
+            raw_response = self.execute_task(task, context, task_tools)
+
             if self._times_executed > self.max_retry_limit:
+                self._logger.log(level="error", message=f"Max retry limit has exceeded.", color="red")
                 raise e
-            raw_response = self.execute_task(task, context)
 
         if self.max_rpm and self._rpm_controller:
             self._rpm_controller.stop_rpm_counter()

versionhq/clients/product/model.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_orig
 from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
-from versionhq.tool import ComposioAppName
+from versionhq.tool.composio_tool_vars import ComposioAppName
 
 
 class ProductProvider(ABC, BaseModel):

versionhq/clients/workflow/model.py

@@ -10,7 +10,7 @@ from versionhq.clients.product.model import Product
 from versionhq.clients.customer.model import Customer
 from versionhq.agent.model import Agent
 from versionhq.team.model import Team
-from versionhq.tool import ComposioAppName
+from versionhq.tool.composio_tool_vars import ComposioAppName
 
 
 class ScoreFormat:

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

@@ -1,3 +1,6 @@
+from enum import Enum
+from typing import Type
+
 JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
 
 
@@ -6,11 +9,14 @@ 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
+
+Option
+litellm.pick_cheapest_chat_models_from_llm_provider(custom_llm_provider: str, n=1)
 """
 
 MODELS = {
     "openai": [
-        "gpt-3.5-turbo",
+        # "gpt-3.5-turbo",
         "gpt-4",
         "gpt-4o",
         "gpt-4o-mini",
@@ -21,9 +27,11 @@ 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",
+        # "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",
@@ -31,10 +39,10 @@ MODELS = {
         "claude-3-opus-20240229",
         "claude-3-haiku-20240307",
     ],
-    "ollama": [
-      "ollama/llama3.1",
-      "ollama/mixtral",
-    ],
+    # "ollama": [
+    #   "ollama/llama3.1",
+    #   "ollama/mixtral",
+    # ],
     # "watson": [
     #     "watsonx/meta-llama/llama-3-1-70b-instruct",
     #     "watsonx/meta-llama/llama-3-1-8b-instruct",
@@ -135,8 +143,8 @@ LLM_API_KEY_NAMES = {
 
 LLM_BASE_URL_KEY_NAMES = {
     "openai":  "OPENAI_API_BASE",
+     "gemini": "GEMINI_API_BASE",
     "anthropic": "ANTHROPIC_API_BASE",
-    "gemini": "GEMINI_API_BASE",
 }
 
 LLM_VARS = {
@@ -225,37 +233,91 @@ LLM_VARS = {
 
 
 """
-Params for litellm.completion() func
+Params for litellm.completion() func. Address common/unique params to each provider.
 """
 
-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"
-]
+PARAMS = {
+    "litellm": [
+        "api_base",
+        "api_version,"
+        "num_retries",
+        "context_window_fallback_dict",
+        "fallbacks",
+        "metadata",
+    ],
+    "common": [
+        "model",
+        "messages",
+        "temperature",
+        "top_p",
+        "max_tokens",
+        "stream",
+        "tools",
+        "tool_choice",
+        "response_format",
+        "n",
+        "stop",
+        "base_url",
+        "api_key",
+    ],
+    "openai": [
+        "timeout",
+        # "temperature",
+        # "top_p",
+        # "n",
+        # "stream",
+        "stream_options",
+        # "stop",
+        "max_compl,etion_tokens",
+        # "max_tokens",
+        "modalities",
+        "prediction",
+        "audio",
+        "presence_penalty",
+        "frequency_penalty",
+        "logit_bias",
+        "user",
+        # "response_format",
+        "seed",
+        # "tools",
+        # "tool_choice",
+        "logprobs",
+        "top_logprobs",
+        "parallel_tool_calls",
+        "extra_headers",
+        "model_list"
+    ],
+    "gemini": [
+        "topK",
+    ]
+}
+
+
+class SchemaType:
+    """
+    A class to store/convert a LLM-valid schema type from the Python Type object.
+    https://swagger.io/docs/specification/v3_0/data-models/data-types/
+    https://cloud.google.com/vertex-ai/docs/reference/rest/v1/Schema#Type
+    """
+
+    def __init__(self, type: Type):
+        self.type = type
+
+    def convert(self) -> str:
+        if self.type is None:
+            return "string"
+
+        if self.type is int:
+            return "integer"
+        elif self.type is float:
+            return "number"
+        elif self.type is str:
+            return "string"
+        elif self.type is dict:
+            return "object"
+        elif self.type is list:
+            return "array"
+        elif self.type is bool:
+            return "boolean"
+        else:
+            return "string"