vectara-agentic 0.2.15__py3-none-any.whl → 0.2.17__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
@@ -38,7 +35,7 @@ from llama_index.core.callbacks.base_handler import BaseCallbackHandler
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.core.agent.runner.base import AgentRunner
 from llama_index.core.agent.types import BaseAgent
-from llama_index.core.workflow import Workflow
+from llama_index.core.workflow import Workflow, Context
 
 from .types import (
     AgentType,
@@ -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:
@@ -169,7 +198,7 @@ class Agent:
 
     def __init__(
         self,
-        tools: list[FunctionTool],
+        tools: List[FunctionTool],
         topic: str = "general",
         custom_instructions: str = "",
         general_instructions: str = GENERAL_INSTRUCTIONS,
@@ -184,7 +213,7 @@ class Agent:
         fallback_agent_config: Optional[AgentConfig] = None,
         chat_history: Optional[list[Tuple[str, str]]] = None,
         validate_tools: bool = False,
-        workflow_cls: Workflow = None,
+        workflow_cls: Optional[Workflow] = None,
         workflow_timeout: int = 120,
     ) -> None:
         """
@@ -258,13 +287,15 @@ class Agent:
             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>".
+            If no invalid tools exist, respond with "<OKAY>" (and nothing else).
             """
             llm = get_llm(LLMRole.MAIN, config=self.agent_config)
-            bad_tools_str = llm.complete(prompt).text
+            bad_tools_str = llm.complete(prompt).text.strip('\n')
             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))
+                numbered = ", ".join(
+                    f"({i}) {tool}" for i, tool in enumerate(bad_tools, 1)
+                )
                 raise ValueError(
                     f"The Agent custom instructions mention these invalid tools: {numbered}"
                 )
@@ -612,7 +643,7 @@ class Agent:
         validate_tools: bool = False,
         fallback_agent_config: Optional[AgentConfig] = None,
         chat_history: Optional[list[Tuple[str, str]]] = None,
-        workflow_cls: Workflow = None,
+        workflow_cls: Optional[Workflow] = None,
         workflow_timeout: int = 120,
     ) -> "Agent":
         """
@@ -681,8 +712,8 @@ class Agent:
         vectara_rerank_limit: Optional[int] = None,
         vectara_rerank_cutoff: Optional[float] = None,
         vectara_diversity_bias: float = 0.2,
-        vectara_udf_expression: str = None,
-        vectara_rerank_chain: List[Dict] = None,
+        vectara_udf_expression: Optional[str] = None,
+        vectara_rerank_chain: Optional[List[Dict]] = None,
         vectara_n_sentences_before: int = 2,
         vectara_n_sentences_after: int = 2,
         vectara_summary_num_results: int = 10,
@@ -1016,7 +1047,7 @@ class Agent:
                 time.sleep(1)
                 attempt += 1
 
-        return AgentResponse(
+        return AgentStreamingResponse(
             response=(
                 f"For {orig_llm} LLM - failure can't be resolved after "
                 f"{max_attempts} attempts ({last_error})."
@@ -1028,7 +1059,11 @@ class Agent:
     # workflow will always get these arguments in the StartEvent: agent, tools, llm, verbose
     # the inputs argument comes from the call to run()
     #
-    async def run(self, inputs: Any, verbose: bool = False) -> Any:
+    async def run(
+        self,
+        inputs: Any,
+        verbose: bool = False,
+    ) -> Any:
         """
         Run a workflow using the agent.
         workflow class must be provided in the agent constructor.
@@ -1036,7 +1071,7 @@ class Agent:
             inputs (Any): The inputs to the workflow.
             verbose (bool, optional): Whether to print verbose output. Defaults to False.
         Returns:
-            Any: The output of the workflow.
+            Any: The output or context of the workflow.
         """
         # Create workflow
         if self.workflow_cls:
@@ -1048,20 +1083,38 @@ class Agent:
         if not isinstance(inputs, self.workflow_cls.InputsModel):
             raise ValueError(f"Inputs must be an instance of {workflow.InputsModel}.")
 
-        # run workflow
-        result = await workflow.run(
-            agent=self,
-            tools=self.tools,
-            llm=self.llm,
-            verbose=verbose,
-            inputs=inputs,
-        )
-
-        # return output in the form of workflow.OutputsModel
+        workflow_context = Context(workflow=workflow)
         try:
-            output = workflow.OutputsModel.model_validate(result)
-        except ValidationError as e:
-            raise ValueError(f"Failed to map workflow output to model: {e}") from e
+            # run workflow
+            result = await workflow.run(
+                ctx=workflow_context,
+                agent=self,
+                tools=self.tools,
+                llm=self.llm,
+                verbose=verbose,
+                inputs=inputs,
+            )
+
+            # return output in the form of workflow.OutputsModel(BaseModel)
+            try:
+                output = workflow.OutputsModel.model_validate(result)
+            except ValidationError as e:
+                raise ValueError(f"Failed to map workflow output to model: {e}") from e
+
+        except Exception as e:
+            outputs_model_on_fail_cls = getattr(workflow.__class__, "OutputModelOnFail", None)
+            if outputs_model_on_fail_cls:
+                model_fields = outputs_model_on_fail_cls.model_fields
+                input_dict = {
+                    key: await workflow_context.get(key, None)
+                    for key in model_fields
+                }
+
+                # return output in the form of workflow.OutputModelOnFail(BaseModel)
+                output = outputs_model_on_fail_cls.model_validate(input_dict)
+            else:
+                print(f"Vectara Agentic: Workflow failed with unexpected error: {e}")
+                raise type(e)(str(e)).with_traceback(e.__traceback__)
 
         return output
 
@@ -1086,12 +1139,12 @@ class Agent:
                 fn_schema_serialized = {
                     "schema": (
                         fn_schema_cls.model_json_schema()
-                        if hasattr(fn_schema_cls, "model_json_schema")
+                        if fn_schema_cls and hasattr(fn_schema_cls, "model_json_schema")
                         else None
                     ),
                     "metadata": {
-                        "module": fn_schema_cls.__module__,
-                        "class": fn_schema_cls.__name__,
+                        "module": fn_schema_cls.__module__ if fn_schema_cls else None,
+                        "class": fn_schema_cls.__name__ if fn_schema_cls else None,
                     },
                 }
             else:
@@ -1140,44 +1193,69 @@ class Agent:
             if data.get("fallback_agent_config")
             else None
         )
-        tools = []
+        tools: list[FunctionTool] = []
 
         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
 
 

vectara_agentic/sub_query_workflow.py

@@ -50,7 +50,7 @@ class SubQuestionQueryWorkflow(Workflow):
         answer: str
 
     @step
-    async def query(self, ctx: Context, ev: StartEvent) -> QueryEvent:
+    async def query(self, ctx: Context, ev: StartEvent) -> QueryEvent | None:
         """
         Given a user question, and a list of tools, output a list of relevant
         sub-questions, such that the answers to all the sub-questions put together
@@ -130,7 +130,10 @@ class SubQuestionQueryWorkflow(Workflow):
         if sub_questions is None:
             raise ValueError(f"Invalid LLM response format: {response_str}")
         if not sub_questions:
-            raise ValueError("LLM returned empty sub-questions list")
+            # If the LLM returns an empty list, we need to handle it gracefully
+            # We use the original query as a single question fallback
+            print("LLM returned empty sub-questions list")
+            sub_questions = [original_query]
 
         await ctx.set("sub_question_count", len(sub_questions))
         for question in sub_questions: