vectara-agentic 0.2.14__py3-none-any.whl → 0.2.16__py3-none-any.whl

vectara_agentic/agent.py

@@ -14,14 +14,11 @@ import importlib
 from collections import Counter
 import inspect
 from inspect import Signature, Parameter, ismethod
-
+from pydantic import Field, create_model, ValidationError, BaseModel
 import cloudpickle as pickle
 
 from dotenv import load_dotenv
 
-from pydantic import Field, create_model, ValidationError
-
-
 from llama_index.core.memory import ChatMemoryBuffer
 from llama_index.core.llms import ChatMessage, MessageRole
 from llama_index.core.tools import FunctionTool
@@ -145,21 +142,53 @@ def get_field_type(field_schema: dict) -> Any:
         "array": list,
         "object": dict,
         "number": float,
+        "null": type(None),
     }
+    if not field_schema:  # Handles empty schema {}
+        return Any
+
     if "anyOf" in field_schema:
         types = []
-        for option in field_schema["anyOf"]:
-            # If the option has a type, convert it; otherwise, use Any.
-            if "type" in option:
-                types.append(json_type_to_python.get(option["type"], Any))
-            else:
-                types.append(Any)
-        # Return a Union of the types. For example, Union[str, int]
+        for option_schema in field_schema["anyOf"]:
+            types.append(get_field_type(option_schema))  # Recursive call
+        if not types:
+            return Any
         return Union[tuple(types)]
-    elif "type" in field_schema:
-        return json_type_to_python.get(field_schema["type"], Any)
-    else:
-        return Any
+
+    if "type" in field_schema and isinstance(field_schema["type"], list):
+        types = []
+        for type_name in field_schema["type"]:
+            if type_name == "array":
+                item_schema = field_schema.get("items", {})
+                types.append(List[get_field_type(item_schema)])
+            elif type_name in json_type_to_python:
+                types.append(json_type_to_python[type_name])
+            else:
+                types.append(Any)  # Fallback for unknown types in the list
+        if not types:
+            return Any
+        return Union[tuple(types)]  # type: ignore
+
+    if "type" in field_schema:
+        schema_type_name = field_schema["type"]
+        if schema_type_name == "array":
+            item_schema = field_schema.get(
+                "items", {}
+            )  # Default to Any if "items" is missing
+            return List[get_field_type(item_schema)]
+
+        return json_type_to_python.get(schema_type_name, Any)
+
+    # If only "items" is present (implies array by some conventions, but less standard)
+    # Or if it's a schema with other keywords like 'properties' (implying object)
+    # For simplicity, if no "type" or "anyOf" at this point, default to Any or add more specific handling.
+    # If 'properties' in field_schema or 'additionalProperties' in field_schema, it's likely an object.
+    if "properties" in field_schema or "additionalProperties" in field_schema:
+        # This path might need to reconstruct a nested Pydantic model if you encounter such schemas.
+        # For now, treating as 'dict' or 'Any' might be a simpler placeholder.
+        return dict  # Or Any, or more sophisticated object reconstruction.
+
+    return Any
 
 
 class Agent:
@@ -248,19 +277,27 @@ class Agent:
 
         if validate_tools:
             prompt = f"""
-            Given the following instructions, and a list of tool names,
-            Please identify tools mentioned in the instructions that do not exist in the list.
-            Instructions:
+            You are provided these tools:
+            <tools>{','.join(tool_names)}</tools>
+            And these instructions:
+            <instructions>
             {self._custom_instructions}
-            Tool names: {', '.join(tool_names)}
-            Your response should include a comma separated list of tool names that do not exist in the list.
-            Your response should be an empty string if all tools mentioned in the instructions are in the list.
+            </instructions>
+            Your task is to identify invalid tools.
+            A tool is invalid if it is mentioned in the instructions but not in the tools list.
+            A tool's name must have at least two characters.
+            Your response should be a comma-separated list of the invalid tools.
+            If not invalid tools exist, respond with "<OKAY>".
             """
             llm = get_llm(LLMRole.MAIN, config=self.agent_config)
-            bad_tools = llm.complete(prompt).text.split(", ")
-            if bad_tools:
+            bad_tools_str = llm.complete(prompt).text
+            if bad_tools_str and bad_tools_str != "<OKAY>":
+                bad_tools = [tool.strip() for tool in bad_tools_str.split(",")]
+                numbered = ", ".join(
+                    f"({i}) {tool}" for i, tool in enumerate(bad_tools, 1)
+                )
                 raise ValueError(
-                    f"The Agent custom instructions mention these invalid tools: {', '.join(bad_tools)}"
+                    f"The Agent custom instructions mention these invalid tools: {numbered}"
                 )
 
         # Create token counters for the main and tool LLMs
@@ -689,6 +726,7 @@ class Agent:
         vectara_frequency_penalty: Optional[float] = None,
         vectara_presence_penalty: Optional[float] = None,
         vectara_save_history: bool = True,
+        return_direct: bool = False,
     ) -> "Agent":
         """
         Create an agent from a single Vectara corpus
@@ -738,6 +776,7 @@ class Agent:
             vectara_presence_penalty (float, optional): How much to penalize repeating tokens in the response,
                 higher values increasing the diversity of topics.
             vectara_save_history (bool, optional): Whether to save the query in history.
+            return_direct (bool, optional): Whether the agent should return the tool's response directly.
 
         Returns:
             Agent: An instance of the Agent class.
@@ -791,6 +830,7 @@ class Agent:
             save_history=vectara_save_history,
             include_citations=True,
             verbose=verbose,
+            return_direct=return_direct,
         )
 
         assistant_instructions = f"""
@@ -1134,41 +1174,66 @@ class Agent:
         tools = []
 
         for tool_data in data["tools"]:
-            # Recreate the dynamic model using the schema info
+            query_args_model = None
             if tool_data.get("fn_schema"):
                 schema_info = tool_data["fn_schema"]
                 try:
                     module_name = schema_info["metadata"]["module"]
                     class_name = schema_info["metadata"]["class"]
                     mod = importlib.import_module(module_name)
-                    fn_schema_cls = getattr(mod, class_name)
-                    query_args_model = fn_schema_cls
+                    candidate_cls = getattr(mod, class_name)
+                    if inspect.isclass(candidate_cls) and issubclass(
+                        candidate_cls, BaseModel
+                    ):
+                        query_args_model = candidate_cls
+                    else:
+                        # It's not the Pydantic model class we expected (e.g., it's the function itself)
+                        # Force fallback to JSON schema reconstruction by raising an error.
+                        raise ImportError(
+                            f"Retrieved '{class_name}' from '{module_name}' is not a Pydantic BaseModel class. "
+                            "Falling back to JSON schema reconstruction."
+                        )
                 except Exception:
                     # Fallback: rebuild using the JSON schema
                     field_definitions = {}
-                    for field, values in (
-                        schema_info.get("schema", {}).get("properties", {}).items()
+                    json_schema_to_rebuild = schema_info.get("schema")
+                    if json_schema_to_rebuild and isinstance(
+                        json_schema_to_rebuild, dict
                     ):
-                        field_type = get_field_type(values)
-                        if "default" in values:
-                            field_definitions[field] = (
-                                field_type,
-                                Field(
-                                    description=values.get("description", ""),
-                                    default=values["default"],
-                                ),
-                            )
-                        else:
-                            field_definitions[field] = (
-                                field_type,
-                                Field(description=values.get("description", "")),
-                            )
-                    query_args_model = create_model(
-                        schema_info.get("schema", {}).get("title", "QueryArgs"),
-                        **field_definitions,
-                    )
-            else:
-                query_args_model = create_model("QueryArgs")
+                        for field, values in json_schema_to_rebuild.get(
+                            "properties", {}
+                        ).items():
+                            field_type = get_field_type(values)
+                            field_description = values.get(
+                                "description"
+                            )  # Defaults to None
+                            if "default" in values:
+                                field_definitions[field] = (
+                                    field_type,
+                                    Field(
+                                        description=field_description,
+                                        default=values["default"],
+                                    ),
+                                )
+                            else:
+                                field_definitions[field] = (
+                                    field_type,
+                                    Field(description=field_description),
+                                )
+                        query_args_model = create_model(
+                            json_schema_to_rebuild.get(
+                                "title", f"{tool_data['name']}_QueryArgs"
+                            ),
+                            **field_definitions,
+                        )
+                    else:  # If schema part is missing or not a dict, create a default empty model
+                        query_args_model = create_model(
+                            f"{tool_data['name']}_QueryArgs"
+                        )
+
+            # If fn_schema was not in tool_data or reconstruction failed badly, default to empty pydantic model
+            if query_args_model is None:
+                query_args_model = create_model(f"{tool_data['name']}_QueryArgs")
 
             fn = (
                 pickle.loads(tool_data["fn"].encode("latin-1"))

vectara_agentic/db_tools.py

@@ -112,7 +112,7 @@ class DatabaseTools:
             List[str]: a list of Document objects from the database.
         """
         if sql_query is None:
-            raise ValueError("A query parameter is necessary to filter the data")
+            raise ValueError("A query parameter is necessary to filter the data.")
 
         count_query = f"SELECT COUNT(*) FROM ({sql_query})"
         try:
@@ -123,7 +123,7 @@ class DatabaseTools:
         if num_rows > self.max_rows:
             return [
                 f"The query is expected to return more than {self.max_rows} rows. "
-                "Please refactor your query to make it return less rows. "
+                "Please refactor your query to make it return less rows and try again. "
             ]
         try:
             res = self._load_data(sql_query)

vectara_agentic/llm_utils.py

@@ -69,12 +69,16 @@ def get_tokenizer_for_model(
     """
     Get the tokenizer for the specified model, as determined by the role & config.
     """
-    model_provider, model_name = _get_llm_params_for_role(role, config)
-    if model_provider == ModelProvider.OPENAI:
-        # This might raise an exception if the model_name is unknown to tiktoken
-        return tiktoken.encoding_for_model(model_name).encode
-    if model_provider == ModelProvider.ANTHROPIC:
-        return Anthropic().tokenizer
+    try:
+        model_provider, model_name = _get_llm_params_for_role(role, config)
+        if model_provider == ModelProvider.OPENAI:
+            # This might raise an exception if the model_name is unknown to tiktoken
+            return tiktoken.encoding_for_model(model_name).encode
+        if model_provider == ModelProvider.ANTHROPIC:
+            return Anthropic().tokenizer
+    except Exception:
+        print(f"Error getting tokenizer for model {model_name}, ignoring")
+        return None
     return None