versionhq 1.1.4.4__py3-none-any.whl

versionhq/agent/model.py

@@ -0,0 +1,472 @@
+import os
+import uuid
+from abc import ABC
+from typing import Any, Dict, List, Optional, TypeVar, Union
+from dotenv import load_dotenv
+from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator
+
+from versionhq._utils.cache_handler import CacheHandler
+from versionhq._utils.logger import Logger
+from versionhq._utils.rpm_controller import RPMController
+from versionhq._utils.usage_metrics import UsageMetrics
+from versionhq.agent.parser import AgentAction
+from versionhq.llm.llm_vars import LLM_VARS
+from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW
+from versionhq.task import TaskOutputFormat
+from versionhq.task.model import ResponseField
+from versionhq.tool.model import Tool, ToolCalled
+from versionhq.tool.tool_handler import ToolHandler
+
+load_dotenv(override=True)
+T = TypeVar("T", bound="Agent")
+
+
+# def _format_answer(agent, answer: str) -> Union[AgentAction, AgentFinish]:
+#     return AgentParser(agent=agent).parse(answer)
+
+# def mock_agent_ops_provider():
+#     def track_agent(*args, **kwargs):
+#         def noop(f):
+#             return f
+#         return noop
+#     return track_agent
+
+# track_agent = mock_agent_ops_provider()
+
+# agentops = None
+# if os.environ.get("AGENTOPS_API_KEY"):
+#     try:
+#         from agentops import track_agent
+#     except ImportError:
+#         track_agent = mock_agent_ops_provider()
+# else:
+#    track_agent = mock_agent_ops_provider()
+
+
+class TokenProcess:
+    total_tokens: int = 0
+    prompt_tokens: int = 0
+    cached_prompt_tokens: int = 0
+    completion_tokens: int = 0
+    successful_requests: int = 0
+
+    def sum_prompt_tokens(self, tokens: int):
+        self.prompt_tokens = self.prompt_tokens + tokens
+        self.total_tokens = self.total_tokens + tokens
+
+    def sum_completion_tokens(self, tokens: int):
+        self.completion_tokens = self.completion_tokens + tokens
+        self.total_tokens = self.total_tokens + tokens
+
+    def sum_cached_prompt_tokens(self, tokens: int):
+        self.cached_prompt_tokens = self.cached_prompt_tokens + tokens
+
+    def sum_successful_requests(self, requests: int):
+        self.successful_requests = self.successful_requests + requests
+
+    def get_summary(self) -> UsageMetrics:
+        return UsageMetrics(
+            total_tokens=self.total_tokens,
+            prompt_tokens=self.prompt_tokens,
+            cached_prompt_tokens=self.cached_prompt_tokens,
+            completion_tokens=self.completion_tokens,
+            successful_requests=self.successful_requests,
+        )
+
+
+# @track_agent()
+class Agent(ABC, BaseModel):
+    """
+    Base class for third-party agents that LLM runs.
+    The agent can execute tasks alone or team. When the agent belongs to team, it needs to prioritize the team.
+    * (Temp) Comment out all the optional fields except for Team and LLM settings for convenience.
+    """
+
+    __hash__ = object.__hash__
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=False))
+    _rpm_controller: Optional[RPMController] = PrivateAttr(default=None)
+    _request_within_rpm_limit: Any = PrivateAttr(default=None)
+    _token_process: TokenProcess = PrivateAttr(default_factory=TokenProcess)
+    _times_executed: int = PrivateAttr(default=0)
+
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    agent_ops_agent_name: str = None
+    agent_ops_agent_id: str = None
+    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: str = Field(description="context passed to the LLM")
+
+    # tools
+    tools: Optional[List[Any]] = Field(default_factory=list)
+    tool_handler: InstanceOf[ToolHandler] = Field(
+        default=None, description="handle tool cache and last used tool"
+    )
+
+    # team, rules of task executions
+    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[Any] = Field(
+        default=None,
+        description="Callback to be executed after each step of the agent execution",
+    )
+
+    # llm settings cascaded to the LLM model
+    llm: Union[str, InstanceOf[LLM], Any] = Field(default=None)
+    function_calling_llm: Union[str, InstanceOf[LLM], 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"
+    )
+    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."
+    )
+
+    # config, cache, error handling
+    config: Optional[Dict[str, Any]] = Field(
+        default=None, exclude=True, description="Configuration for the agent"
+    )
+    cache: bool = Field(
+        default=True, description="Whether the agent should use a cache for tool usage."
+    )
+    cache_handler: InstanceOf[CacheHandler] = Field(
+        default=None, description="An instance of the CacheHandler class."
+    )
+    formatting_errors: int = Field(
+        default=0, description="Number of formatting errors."
+    )
+    verbose: bool = Field(
+        default=True, description="Verbose mode for the Agent Execution"
+    )
+
+    def __repr__(self):
+        return f"Agent(role={self.role}, goal={self.goal}, backstory={self.backstory})"
+
+    @model_validator(mode="after")
+    def set_up_llm(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.
+        The base model is selected on the client app, else use the default model.
+        """
+
+        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 []
+        )
+
+        if isinstance(self.llm, LLM):
+            self.llm.timeout = self.max_execution_time
+            self.llm.max_token = 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
+
+        elif isinstance(self.llm, str):
+            self.llm = LLM(
+                model=self.llm,
+                timeout=self.max_execution_time,
+                max_tokens=self.max_tokens,
+                callbacks=callbacks,
+            )
+
+            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
+
+        elif self.llm is None:
+            model_name = os.environ.get(
+                "LITELLM_MODEL_NAME", os.environ.get("MODEL", "gpt-4o-mini")
+            )
+            llm_params = {
+                "model": model_name,
+                "timeout": self.max_execution_time,
+                "max_tokens": self.max_tokens,
+                "callbacks": callbacks,
+            }
+            api_base = os.environ.get(
+                "OPENAI_API_BASE", os.environ.get("OPENAI_BASE_URL", None)
+            )
+            if api_base:
+                llm_params["base_url"] = api_base
+
+            set_provider = model_name.split("/")[0] if "/" in model_name else "openai"
+            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
+
+        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", 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
+            }  # factor out None values
+            self.llm = LLM(**llm_params)
+
+        """
+        Set up funcion_calling LLM as well. For the sake of convenience, use the same metrics as the base LLM settings.
+        """
+        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
+
+            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
+
+            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,
+                    )
+        return self
+
+    @model_validator(mode="after")
+    def set_up_tools(self):
+        """
+        Similar to the LLM set up, when the agent has tools, we will declare them using the Tool class.
+        """
+
+        if not self.tools:
+            pass
+
+        else:
+            tools_in_class_format = []
+            for tool in self.tools:
+                if isinstance(tool, Tool):
+                    tools_in_class_format.append(tool)
+                elif isinstance(tool, str):
+                    tool_to_add = Tool(name=tool)
+                    tools_in_class_format.append(tool_to_add)
+                else:
+                    pass
+            self.tools = tools_in_class_format
+
+        return self
+
+    def invoke(
+        self,
+        prompts: str,
+        output_formats: List[TaskOutputFormat],
+        response_fields: List[ResponseField],
+        **kwargs,
+    ) -> 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 = 0
+
+        messages = []
+        messages.append({"role": "user", "content": prompts})  #! REFINEME
+        messages.append({"role": "assistant", "content": self.backstory})
+        print("Messages sent to the model:", messages)
+
+        callbacks = kwargs.get("callbacks", None)
+
+        response = self.llm.call(
+            messages=messages,
+            output_formats=output_formats,
+            field_list=response_fields,
+            callbacks=callbacks,
+        )
+        task_execution_counter += 1
+        print("Agent's #1 res: ", response)
+
+        if (
+            response is None or response == ""
+        ) and task_execution_counter < self.max_retry_limit:
+            while task_execution_counter <= self.max_retry_limit:
+                response = self.llm.call(
+                    messages=messages,
+                    output_formats=output_formats,
+                    field_list=response_fields,
+                    callbacks=callbacks,
+                )
+                task_execution_counter += 1
+                print(f"Agent's #{task_execution_counter} res: ", response)
+
+        elif response is None or response == "":
+            print("Received None or empty response from LLM call.")
+            raise ValueError("Invalid response from LLM call - None or empty.")
+
+        return {"output": response.output if hasattr(response, "output") else response}
+
+    def execute_task(self, task, context: Optional[str] = None) -> str:
+        """
+        Execute the task and return the output in string.
+        To simplify, the tools are cascaded from the `tools_called` under the `task` Task instance if any.
+        When the tools are given, the agent must use them.
+        The agent must consider the context to excute the task as well when it is given.
+        """
+
+        task_prompt = task.prompt()
+        # if context:
+        #     task_prompt = self.i18n.slice("task_with_context").format(task=task_prompt, context=context)
+
+        tool_results = []
+        if task.tools_called:
+            for tool_called in task.tools_called:
+                tool_result = tool_called.tool.run()
+                tool_results.append(tool_result)
+
+            if task.take_tool_res_as_final:
+                return tool_results
+
+        # if self.team and self.team._train:
+        #     task_prompt = self._training_handler(task_prompt=task_prompt)
+        # else:
+        #     task_prompt = self._use_trained_data(task_prompt=task_prompt)
+
+        try:
+            result = self.invoke(
+                prompts=task_prompt,
+                output_formats=task.expected_output_formats,
+                response_fields=task.output_field_list,
+            )["output"]
+
+        except Exception as e:
+            self._times_executed += 1
+            if self._times_executed > self.max_retry_limit:
+                raise e
+            result = self.execute_task(
+                task, context, [tool_called.tool for tool_called in task.tools_called]
+            )
+
+        if self.max_rpm and self._rpm_controller:
+            self._rpm_controller.stop_rpm_counter()
+
+        # for tool_result in self.tools_results:
+        #     if tool_result.get("result_as_answer", False):
+        #         result = tool_result["result"]
+
+        return result

versionhq/agent/parser.py

@@ -0,0 +1,148 @@
+import re
+from typing import Any, Union
+from json_repair import repair_json
+
+from versionhq._utils.i18n import I18N
+
+
+FINAL_ANSWER_ACTION = "Final Answer:"
+MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action:' after 'Thought:'. I will do right next, and don't use a tool I have already used.\n"
+MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action Input:' after 'Action:'. I will do right next, and don't use a tool I have already used.\n"
+FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = "I did it wrong. Tried to both perform Action and give a Final Answer at the same time, I must do one or the other"
+
+
+class AgentAction:
+    thought: str
+    tool: str
+    tool_input: str
+    text: str
+    result: str
+
+    def __init__(self, thought: str, tool: str, tool_input: str, text: str):
+        self.thought = thought
+        self.tool = tool
+        self.tool_input = tool_input
+        self.text = text
+
+
+class AgentFinish:
+    thought: str
+    output: str
+    text: str
+
+    def __init__(self, thought: str, output: str, text: str):
+        self.thought = thought
+        self.output = output
+        self.text = text
+
+
+class OutputParserException(Exception):
+    error: str
+
+    def __init__(self, error: str):
+        self.error = error
+
+
+class AgentParser:
+    """
+    Parses ReAct-style LLM calls that have a single tool input.
+
+    Expects output to be in one of two formats.
+
+    If the output signals that an action should be taken,
+    should be in the below format. This will result in an AgentAction
+    being returned.
+
+    Thought: agent thought here
+    Action: search
+    Action Input: what is the temperature in SF?
+
+    If the output signals that a final answer should be given,
+    should be in the below format. This will result in an AgentFinish
+    being returned.
+
+    Thought: agent thought here
+    Final Answer: The temperature is 100 degrees
+    """
+
+    agent: Any = None
+
+    def __init__(self, agent: Any):
+        self.agent = agent
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        thought = self._extract_thought(text)
+        includes_answer = FINAL_ANSWER_ACTION in text
+        regex = (
+            r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
+        )
+        action_match = re.search(regex, text, re.DOTALL)
+        if action_match:
+            if includes_answer:
+                raise OutputParserException(
+                    f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}"
+                )
+            action = action_match.group(1)
+            clean_action = self._clean_action(action)
+
+            action_input = action_match.group(2).strip()
+
+            tool_input = action_input.strip(" ").strip('"')
+            safe_tool_input = self._safe_repair_json(tool_input)
+
+            return AgentAction(thought, clean_action, safe_tool_input, text)
+
+        elif includes_answer:
+            final_answer = text.split(FINAL_ANSWER_ACTION)[-1].strip()
+            return AgentFinish(thought, final_answer, text)
+
+        if not re.search(r"Action\s*\d*\s*:[\s]*(.*?)", text, re.DOTALL):
+            # self.agent.increment_formatting_errors()
+            raise OutputParserException(
+                f"{MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE}",
+            )
+        elif not re.search(
+            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)", text, re.DOTALL
+        ):
+            # self.agent.increment_formatting_errors()
+            raise OutputParserException(MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE)
+        else:
+            _i18n = I18N()
+            format = self._i18n.slice("format_without_tools")
+            error = f"{format}"
+            # self.agent.increment_formatting_errors()
+            raise OutputParserException(error)
+
+    def _extract_thought(self, text: str) -> str:
+        regex = r"(.*?)(?:\n\nAction|\n\nFinal Answer)"
+        thought_match = re.search(regex, text, re.DOTALL)
+        if thought_match:
+            return thought_match.group(1).strip()
+        return ""
+
+    def _clean_action(self, text: str) -> str:
+        """Clean action string by removing non-essential formatting characters."""
+        return re.sub(r"^\s*\*+\s*|\s*\*+\s*$", "", text).strip()
+
+    def _safe_repair_json(self, tool_input: str) -> str:
+        UNABLE_TO_REPAIR_JSON_RESULTS = ['""', "{}"]
+
+        # Skip repair if the input starts and ends with square brackets
+        # Explanation: The JSON parser has issues handling inputs that are enclosed in square brackets ('[]').
+        # These are typically valid JSON arrays or strings that do not require repair. Attempting to repair such inputs
+        # might lead to unintended alterations, such as wrapping the entire input in additional layers or modifying
+        # the structure in a way that changes its meaning. By skipping the repair for inputs that start and end with
+        # square brackets, we preserve the integrity of these valid JSON structures and avoid unnecessary modifications.
+        if tool_input.startswith("[") and tool_input.endswith("]"):
+            return tool_input
+
+        # Before repair, handle common LLM issues:
+        # 1. Replace """ with " to avoid JSON parser errors
+
+        tool_input = tool_input.replace('"""', '"')
+
+        result = repair_json(tool_input)
+        if result in UNABLE_TO_REPAIR_JSON_RESULTS:
+            return tool_input
+
+        return str(result)

versionhq/clients/customer/model.py

@@ -0,0 +1,57 @@
+import uuid
+from abc import ABC
+from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
+from pydantic import (
+    UUID4,
+    InstanceOf,
+    BaseModel,
+    ConfigDict,
+    Field,
+    create_model,
+    field_validator,
+    model_validator,
+)
+from pydantic_core import PydanticCustomError
+
+from versionhq.clients.product.model import Product, ProductProvider
+
+
+class Customer(ABC, BaseModel):
+    """
+    Store the minimal information on the customer.
+    """
+
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    name: Optional[str] = Field(default=None, description="customer's name if any")
+    product_list: Optional[List[Product]] = Field(
+        default=list, description="store products that the customer is associated with"
+    )
+    analysis: str = Field(
+        default=None, description="store the latest analysis results on the customer"
+    )
+    on_workflow: bool = Field(
+        default=False, description="`True` if they are on some messaging workflows"
+    )
+    on: Optional[str] = Field(
+        default=None, description="destination service for this customer if any"
+    )
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError(
+                "may_not_set_field", "This field is not to be set by the user.", {}
+            )
+
+    def customer_to(self) -> List[ProductProvider]:
+        """
+        Return list of ProductProvider if the customer has `product_list`
+        """
+
+        res = list
+        if self.product_list:
+            for item in self.product_list:
+                if item.provider not in res:
+                    res.appned(item.provider)
+        return res