vectara-agentic 0.2.21__py3-none-any.whl → 0.2.23__py3-none-any.whl

tests/test_agent_type.py

@@ -19,10 +19,13 @@ react_config_anthropic = AgentConfig(
     tool_llm_provider=ModelProvider.ANTHROPIC,
 )
 
+# React with Google does not work with Gemini 2.5-flash
 react_config_gemini = AgentConfig(
     agent_type=AgentType.REACT,
     main_llm_provider=ModelProvider.GEMINI,
+    main_llm_model_name="models/gemini-2.0-flash",
     tool_llm_provider=ModelProvider.GEMINI,
+    tool_llm_model_name="models/gemini-2.0-flash",
 )
 
 react_config_together = AgentConfig(
@@ -97,7 +100,7 @@ class TestAgentType(unittest.TestCase):
         )
         agent.chat("What is 5 times 10. Only give the answer, nothing else")
         agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        res = agent.chat("what is the result of multiplying the results of the last two multiplications. Only give the answer, nothing else.")
         self.assertIn("1050", res.response)
 
         agent = Agent(
@@ -108,7 +111,7 @@ class TestAgentType(unittest.TestCase):
         )
         agent.chat("What is 5 times 10. Only give the answer, nothing else")
         agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        res = agent.chat("what is the result of multiplying the results of the last two multiplications. Only give the answer, nothing else.")
         self.assertIn("1050", res.response)
 
     def test_together(self):

tests/test_groq.py

@@ -1,59 +1,18 @@
 import unittest
 
-from pydantic import Field, BaseModel
-
 from vectara_agentic.agent import Agent, AgentType
 from vectara_agentic.agent_config import AgentConfig
-from vectara_agentic.tools import VectaraToolFactory
+from vectara_agentic.tools import ToolsFactory
 from vectara_agentic.types import ModelProvider
 
-
 import nest_asyncio
 nest_asyncio.apply()
 
-tickers = {
-    "C": "Citigroup",
-    "COF": "Capital One",
-    "JPM": "JPMorgan Chase",
-    "AAPL": "Apple Computer",
-    "GOOG": "Google",
-    "AMZN": "Amazon",
-    "SNOW": "Snowflake",
-    "TEAM": "Atlassian",
-    "TSLA": "Tesla",
-    "NVDA": "Nvidia",
-    "MSFT": "Microsoft",
-    "AMD": "Advanced Micro Devices",
-    "INTC": "Intel",
-    "NFLX": "Netflix",
-    "STT": "State Street",
-    "BK": "Bank of New York Mellon",
-}
-years = list(range(2015, 2025))
-
-
 def mult(x: float, y: float) -> float:
     "Multiply two numbers"
     return x * y
 
 
-def get_company_info() -> list[str]:
-    """
-    Returns a dictionary of companies you can query about. Always check this before using any other tool.
-    The output is a dictionary of valid ticker symbols mapped to company names.
-    You can use this to identify the companies you can query about, and their ticker information.
-    """
-    return tickers
-
-
-def get_valid_years() -> list[str]:
-    """
-    Returns a list of the years for which financial reports are available.
-    Always check this before using any other tool.
-    """
-    return years
-
-
 fc_config_groq = AgentConfig(
     agent_type=AgentType.FUNCTION_CALLING,
     main_llm_provider=ModelProvider.GROQ,
@@ -63,53 +22,21 @@ fc_config_groq = AgentConfig(
 
 class TestGROQ(unittest.TestCase):
 
-    def test_tool_with_many_arguments(self):
-
-        vectara_corpus_key = "vectara-docs_1"
-        vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
-        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
-
-        class QueryToolArgs(BaseModel):
-            arg1: str = Field(description="the first argument", examples=["val1"])
-            arg2: str = Field(description="the second argument", examples=["val2"])
-            arg3: str = Field(description="the third argument", examples=["val3"])
-            arg4: str = Field(description="the fourth argument", examples=["val4"])
-            arg5: str = Field(description="the fifth argument", examples=["val5"])
-            arg6: str = Field(description="the sixth argument", examples=["val6"])
-            arg7: str = Field(description="the seventh argument", examples=["val7"])
-            arg8: str = Field(description="the eighth argument", examples=["val8"])
-            arg9: str = Field(description="the ninth argument", examples=["val9"])
-            arg10: str = Field(description="the tenth argument", examples=["val10"])
-            arg11: str = Field(description="the eleventh argument", examples=["val11"])
-            arg12: str = Field(description="the twelfth argument", examples=["val12"])
-            arg13: str = Field(
-                description="the thirteenth argument", examples=["val13"]
-            )
-            arg14: str = Field(
-                description="the fourteenth argument", examples=["val14"]
-            )
-            arg15: str = Field(description="the fifteenth argument", examples=["val15"])
-
-        query_tool_1 = vec_factory.create_rag_tool(
-            tool_name="rag_tool",
-            tool_description="""
-            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
-            We are using this tool to test the tool factory works and does not crash with OpenAI.
-            """,
-            tool_args_schema=QueryToolArgs,
-        )
-
+    def test_multiturn(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
         agent = Agent(
-            tools=[query_tool_1],
-            topic="Sample topic",
-            custom_instructions="Call the tool with 15 arguments",
-            agent_config=fc_config_groq,
-        )
-        res = agent.chat("What is the stock price?")
-        self.assertTrue(
-            any(sub in str(res) for sub in ["I don't know", "I do not have", "please specify which company"])
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
         )
 
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
+        self.assertEqual(res.response, "1050")
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_workflow.py

@@ -1,9 +1,5 @@
 import unittest
 
-from pydantic import BaseModel
-
-from llama_index.core.workflow import WorkflowTimeoutError
-
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.tools import ToolsFactory
@@ -68,7 +64,7 @@ class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
 
 class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
 
-    async def test_workflow_failure(self):
+    async def test_workflow_failure_sub_question(self):
         tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
         topic = "AI topic"
         instructions = "You are a helpful AI assistant."
@@ -84,50 +80,27 @@ class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
         inputs = SubQuestionQueryWorkflow.InputsModel(
             query="Compute 5 times 3, then add 7 to the result."
         )
+        res = await agent.run(inputs=inputs)
+        self.assertIsInstance(res, SubQuestionQueryWorkflow.OutputModelOnFail)
 
-        res = None
-
-        try:
-            res = await agent.run(inputs=inputs)
-        except Exception as e:
-            self.assertIsInstance(e, WorkflowTimeoutError)
-
-        self.assertIsNone(res)
-
-    async def test_workflow_with_fail_class(self):
+    async def test_workflow_failure_seq_sub_question(self):
         tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
         topic = "AI topic"
         instructions = "You are a helpful AI assistant."
-
-        class SubQuestionQueryWorkflowWithFailClass(SubQuestionQueryWorkflow):
-            class OutputModelOnFail(BaseModel):
-                """
-                In case of failure, returns the user's original query
-                """
-                original_query: str
-
         agent = Agent(
             tools=tools,
             topic=topic,
             custom_instructions=instructions,
             agent_config = AgentConfig(),
-            workflow_cls = SubQuestionQueryWorkflowWithFailClass,
+            workflow_cls = SequentialSubQuestionsWorkflow,
             workflow_timeout = 1
         )
 
-        inputs = SubQuestionQueryWorkflow.InputsModel(
+        inputs = SequentialSubQuestionsWorkflow.InputsModel(
             query="Compute 5 times 3, then add 7 to the result."
         )
-
-        res = None
-
-        try:
-            res = await agent.run(inputs=inputs)
-        except Exception as e:
-            assert isinstance(e, WorkflowTimeoutError)
-
-        self.assertIsInstance(res, SubQuestionQueryWorkflowWithFailClass.OutputModelOnFail)
-        self.assertEqual(res.original_query, "Compute 5 times 3, then add 7 to the result.")
+        res = await agent.run(inputs=inputs)
+        self.assertIsInstance(res, SequentialSubQuestionsWorkflow.OutputModelOnFail)
 
 
 if __name__ == "__main__":

vectara_agentic/_prompts.py

@@ -44,6 +44,7 @@ GENERAL_INSTRUCTIONS = """
 - If you are provided with database tools use them for analytical queries (such as counting, calculating max, min, average, sum, or other statistics).
   For each database, the database tools include: x_list_tables, x_load_data, x_describe_tables, x_load_unique_values, and x_load_sample_data, where 'x' in the database name.
   for example, if the database name is "ev", the tools are: ev_list_tables, ev_load_data, ev_describe_tables, ev_load_unique_values, and ev_load_sample_data.
+  Use ANSI SQL-92 syntax for the SQL queries, and do not use any other SQL dialect.
   Before using the x_load_data with a SQL query, always follow these discovery steps:
   - call the x_list_tables tool to list of available tables in the x database.
   - Call the x_describe_tables tool to understand the schema of each table you want to query data from.

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.21"
+__version__ = "0.2.23"

vectara_agentic/agent.py

@@ -15,6 +15,8 @@ from collections import Counter
 import inspect
 from inspect import Signature, Parameter, ismethod
 from pydantic import Field, create_model, ValidationError, BaseModel
+from pydantic_core import PydanticUndefined
+
 import cloudpickle as pickle
 
 from dotenv import load_dotenv
@@ -1083,6 +1085,15 @@ class Agent:
         if not isinstance(inputs, self.workflow_cls.InputsModel):
             raise ValueError(f"Inputs must be an instance of {workflow.InputsModel}.")
 
+        outputs_model_on_fail_cls = getattr(workflow.__class__, "OutputModelOnFail", None)
+        if outputs_model_on_fail_cls:
+            fields_without_default = []
+            for name, field_info in outputs_model_on_fail_cls.model_fields.items():
+                if field_info.default_factory is PydanticUndefined:
+                    fields_without_default.append(name)
+            if fields_without_default:
+                raise ValueError(f"Fields without default values: {fields_without_default}")
+
         workflow_context = Context(workflow=workflow)
         try:
             # run workflow
@@ -1102,15 +1113,14 @@ class Agent:
                 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)
+            _missing = object()
             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)
+                input_dict = {}
+                for key in model_fields:
+                    value = await workflow_context.get(key, default=_missing)
+                    if value is not _missing:
+                        input_dict[key] = value
                 output = outputs_model_on_fail_cls.model_validate(input_dict)
             else:
                 print(f"Vectara Agentic: Workflow failed with unexpected error: {e}")
@@ -1126,9 +1136,14 @@ class Agent:
         return json.dumps(self.to_dict())
 
     @classmethod
-    def loads(cls, data: str) -> "Agent":
+    def loads(
+        cls,
+        data: str,
+        agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
+        query_logging_callback: Optional[Callable[[str, str], None]] = None
+    ) -> "Agent":
         """Create an Agent instance from a JSON string."""
-        return cls.from_dict(json.loads(data))
+        return cls.from_dict(json.loads(data), agent_progress_callback, query_logging_callback)
 
     def to_dict(self) -> Dict[str, Any]:
         """Serialize the Agent instance to a dictionary."""
@@ -1185,7 +1200,12 @@ class Agent:
         }
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Agent":
+    def from_dict(
+        cls,
+        data: Dict[str, Any],
+        agent_progress_callback: Optional[Callable] = None,
+        query_logging_callback: Optional[Callable] = None
+    ) -> "Agent":
         """Create an Agent instance from a dictionary."""
         agent_config = AgentConfig.from_dict(data["agent_config"])
         fallback_agent_config = (
@@ -1286,6 +1306,8 @@ class Agent:
             verbose=data["verbose"],
             fallback_agent_config=fallback_agent_config,
             workflow_cls=data["workflow_cls"],
+            agent_progress_callback=agent_progress_callback,
+            query_logging_callback=query_logging_callback,
         )
         memory = (
             pickle.loads(data["memory"].encode("latin-1"))
@@ -1294,4 +1316,5 @@ class Agent:
         )
         if memory:
             agent.agent.memory = memory
+            agent.memory = memory
         return agent

vectara_agentic/llm_utils.py

@@ -11,18 +11,54 @@ from llama_index.core.llms import LLM
 from llama_index.llms.openai import OpenAI
 from llama_index.llms.anthropic import Anthropic
 
+# Optional provider imports with graceful fallback
+try:
+    from llama_index.llms.google_genai import GoogleGenAI
+except ImportError:
+    GoogleGenAI = None
+
+try:
+    from llama_index.llms.together import TogetherLLM
+except ImportError:
+    TogetherLLM = None
+
+try:
+    from llama_index.llms.groq import Groq
+except ImportError:
+    Groq = None
+
+try:
+    from llama_index.llms.fireworks import Fireworks
+except ImportError:
+    Fireworks = None
+
+try:
+    from llama_index.llms.bedrock_converse import BedrockConverse
+except ImportError:
+    BedrockConverse = None
+
+try:
+    from llama_index.llms.cohere import Cohere
+except ImportError:
+    Cohere = None
+
+try:
+    from llama_index.llms.openai_like import OpenAILike
+except ImportError:
+    OpenAILike = None
+
 from .types import LLMRole, AgentType, ModelProvider
 from .agent_config import AgentConfig
 
 provider_to_default_model_name = {
     ModelProvider.OPENAI: "gpt-4.1",
     ModelProvider.ANTHROPIC: "claude-sonnet-4-20250514",
-    ModelProvider.TOGETHER: "Qwen/Qwen2.5-72B-Instruct-Turbo",
+    ModelProvider.TOGETHER: "meta-llama/Llama-4-Scout-17B-16E-Instruct",
     ModelProvider.GROQ: "deepseek-r1-distill-llama-70b",
     ModelProvider.FIREWORKS: "accounts/fireworks/models/firefunction-v2",
     ModelProvider.BEDROCK: "us.anthropic.claude-sonnet-4-20250514-v1:0",
     ModelProvider.COHERE: "command-a-03-2025",
-    ModelProvider.GEMINI: "models/gemini-2.0-flash",
+    ModelProvider.GEMINI: "models/gemini-2.5-flash",
 }
 
 DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
@@ -106,8 +142,8 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.GEMINI:
-        from llama_index.llms.google_genai import GoogleGenAI
-
+        if GoogleGenAI is None:
+            raise ImportError("google_genai not available. Install with: pip install llama-index-llms-google-genai")
         llm = GoogleGenAI(
             model=model_name,
             temperature=0,
@@ -116,8 +152,8 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.TOGETHER:
-        from llama_index.llms.together import TogetherLLM
-
+        if TogetherLLM is None:
+            raise ImportError("together not available. Install with: pip install llama-index-llms-together")
         llm = TogetherLLM(
             model=model_name,
             temperature=0,
@@ -125,8 +161,8 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.GROQ:
-        from llama_index.llms.groq import Groq
-
+        if Groq is None:
+            raise ImportError("groq not available. Install with: pip install llama-index-llms-groq")
         llm = Groq(
             model=model_name,
             temperature=0,
@@ -134,12 +170,12 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.FIREWORKS:
-        from llama_index.llms.fireworks import Fireworks
-
+        if Fireworks is None:
+            raise ImportError("fireworks not available. Install with: pip install llama-index-llms-fireworks")
         llm = Fireworks(model=model_name, temperature=0, max_tokens=max_tokens)
     elif model_provider == ModelProvider.BEDROCK:
-        from llama_index.llms.bedrock_converse import BedrockConverse
-
+        if BedrockConverse is None:
+            raise ImportError("bedrock_converse not available. Install with: pip install llama-index-llms-bedrock")
         aws_profile_name = os.getenv("AWS_PROFILE", None)
         aws_region = os.getenv("AWS_REGION", "us-east-2")
 
@@ -151,12 +187,12 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             region_name=aws_region,
         )
     elif model_provider == ModelProvider.COHERE:
-        from llama_index.llms.cohere import Cohere
-
+        if Cohere is None:
+            raise ImportError("cohere not available. Install with: pip install llama-index-llms-cohere")
         llm = Cohere(model=model_name, temperature=0, max_tokens=max_tokens)
     elif model_provider == ModelProvider.PRIVATE:
-        from llama_index.llms.openai_like import OpenAILike
-
+        if OpenAILike is None:
+            raise ImportError("openai_like not available. Install with: pip install llama-index-llms-openai-like")
         llm = OpenAILike(
             model=model_name,
             temperature=0,

vectara_agentic/sub_query_workflow.py

@@ -5,7 +5,7 @@ that takes a user question and a list of tools, and outputs a list of sub-questi
 
 import re
 import json
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from llama_index.core.workflow import (
     step,
@@ -37,6 +37,13 @@ class SubQuestionQueryWorkflow(Workflow):
 
         response: str
 
+    class OutputModelOnFail(BaseModel):
+        """
+        Outputs for the workflow when it fails.
+        """
+
+        qna: list[tuple[str,str]] = Field(default_factory=list, description="List of question-answer pairs")
+
     # Workflow Event types
     class QueryEvent(Event):
         """Event for a query."""
@@ -141,7 +148,7 @@ class SubQuestionQueryWorkflow(Workflow):
 
         return None
 
-    @step(num_workers=4)
+    @step(num_workers=8)
     async def sub_question(self, ctx: Context, ev: QueryEvent) -> AnswerEvent:
         """
         Given a sub-question, return the answer to the sub-question, using the agent.
@@ -149,8 +156,11 @@ class SubQuestionQueryWorkflow(Workflow):
         if await ctx.get("verbose"):
             print(f"Sub-question is {ev.question}")
         agent = await ctx.get("agent")
-        response = await agent.achat(ev.question)
-        return self.AnswerEvent(question=ev.question, answer=str(response))
+        question = ev.question
+        response = await agent.achat(question)
+        answer = str(response)
+        await ctx.set("qna", await ctx.get("qna", []) + [(question, answer)])
+        return self.AnswerEvent(question=question, answer=answer)
 
     @step
     async def combine_answers(self, ctx: Context, ev: AnswerEvent) -> StopEvent | None:
@@ -209,6 +219,15 @@ class SequentialSubQuestionsWorkflow(Workflow):
 
         response: str
 
+    class OutputModelOnFail(BaseModel):
+        """
+        Outputs for the workflow when it fails.
+        """
+
+        qna: list[tuple[str,str]] = Field(
+            default_factory=list, description="List of question-answer pairs"
+        )
+
     # Workflow Event types
     class QueryEvent(Event):
         """Event for a query."""
@@ -322,24 +341,27 @@ class SequentialSubQuestionsWorkflow(Workflow):
             print(f"Sub-question is {ev.question}")
         agent = await ctx.get("agent")
         sub_questions = await ctx.get("sub_questions")
+        question = ev.question
         if ev.prev_answer:
             prev_question = sub_questions[ev.num - 1]
             prompt = f"""
                 The answer to the question '{prev_question}' is: '{ev.prev_answer}'
-                Now answer the following question: '{ev.question}'
+                Now answer the following question: '{question}'
             """
             response = await agent.achat(prompt)
         else:
-            response = await agent.achat(ev.question)
+            response = await agent.achat(question)
+        answer = response.response
         if await ctx.get("verbose"):
-            print(f"Answer is {response}")
+            print(f"Answer is {answer}")
 
         if ev.num + 1 < len(sub_questions):
+            await ctx.set("qna", await ctx.get("qna", []) + [(question, answer)])
             return self.QueryEvent(
                 question=sub_questions[ev.num + 1],
-                prev_answer=response.response,
+                prev_answer=answer,
                 num=ev.num + 1,
             )
 
-        output = self.OutputsModel(response=response.response)
+        output = self.OutputsModel(response=answer)
         return StopEvent(result=output)

vectara_agentic/tools.py

@@ -129,6 +129,8 @@ class VectaraToolFactory:
                 - 'type': the type of each filter attribute in Vectara (doc or part).
                 - 'is_list': whether the filterable attribute is a list.
                 - 'filter_name': the name of the filterable attribute in Vectara.
+            summarize_docs (bool, optional): Whether to summarize the retrieved documents.
+            summarize_llm_name (str, optional): The name of the LLM to use for summarization.
             fixed_filter (str, optional): A fixed Vectara filter condition to apply to all queries.
             lambda_val (Union[List[float] | float], optional): Lambda value (or list of values for each corpora)
                 for the Vectara query, when using hybrid search.

{vectara_agentic-0.2.21.dist-info → vectara_agentic-0.2.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.21
+Version: 0.2.23
 Summary: A Python package for creating AI Assistants and AI Agents with Vectara
 Home-page: https://github.com/vectara/py-vectara-agentic
 Author: Ofer Mendelevitch
@@ -530,6 +530,9 @@ class MyWorkflow(Workflow):
     class OutputsModel(BaseModel):
         answer: str
 
+    class OutputModelOnFail(BaseModel):
+        partial_response: str = ""
+
     @step
     async def my_step(self, ev: StartEvent) -> StopEvent:
         # do something here
@@ -587,6 +590,11 @@ workflow_result = asyncio.run(agent.run(inputs))
 print(workflow_result.answer)
 ```
 
+When a workflow reaches its timeout, the timeout handler builds and returns an `OutputModelOnFail` 
+by reading each field named in that model from the workflow’s Context; for any field that isn’t set in the context, 
+it uses the default value you’ve defined on `OutputModelOnFail`. In other words, every property in `OutputModelOnFail` 
+must declare a default so that even if the corresponding context variable is missing, the model can be fully populated and returned without errors.
+
 ### Built-in Workflows
 
 `vectara-agentic` includes two workflow implementations that you can use right away:

{vectara_agentic-0.2.21.dist-info → vectara_agentic-0.2.23.dist-info}/RECORD

@@ -2,36 +2,36 @@ tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/endpoint.py,sha256=frnpdZQpnuQNNKNYgAn2rFTarNG8MCJaNA77Bw_W22A,1420
 tests/test_agent.py,sha256=BmpJrYN-BLwYasgPhY5Dji-kIpc723e2F6I-nj4EQgc,5510
 tests/test_agent_planning.py,sha256=JwEebGooROAvsQ9JZoaH6KEcrSyv1F0lL4TD4FjP8a8,2213
-tests/test_agent_type.py,sha256=mWo-pTQNDj4fWFPETm5jnb7Y5N48aW35keTVvxdIaCc,7173
+tests/test_agent_type.py,sha256=9ZImIDw7Qz5EV2tX8bDD0tT1IFYghS3-SShpAezHO7s,7381
 tests/test_api_endpoint.py,sha256=M9YGFCy_Jphzq9JznP4ftHqxZ_yu6dgWdX1jRvdsORA,5002
 tests/test_bedrock.py,sha256=23A5_2FRaEl47PzgfUPDL6dgFDPJ9iktz-A-B1UwIhg,1224
 tests/test_fallback.py,sha256=M5YD7NHZ0joVU1frYIr9_OiRAIje5mrXrYVcekzlyGs,2829
 tests/test_gemini.py,sha256=QUBYWhZkX9AjnhPn5qa7sREf6YHZWeJEmYzKwVC23Io,4081
-tests/test_groq.py,sha256=U6DRbsdC-rY1gD_DahwZBDuVN2ZyNUu7317S8JeqWpU,4103
+tests/test_groq.py,sha256=5yTlOLwpzGRmiBPExAuulK6SEO9O13cMJWVSSHX9CsE,1212
 tests/test_private_llm.py,sha256=-bQBI69Z-SwhhQJGzyC9GGM4kz5c6T5kAbXLbqn_G7E,2248
 tests/test_return_direct.py,sha256=Y_K_v88eS_kJfxE6A0Yghma0nUT8u6COitj0SNnZGNs,1523
 tests/test_serialization.py,sha256=Ed23GN2zhSJNdPFrVK4aqLkOhJKviczR_o0t-r9TuRI,4762
 tests/test_tools.py,sha256=j6wY-jqeerE4Q7lxzuxbftRyzPLHE1scWKNFLgX7wSk,17138
 tests/test_vectara_llms.py,sha256=gw5KQ4XT3L-_A6yj2jKqj-QomCjOb9VESKBtBH2Xb8s,2362
-tests/test_workflow.py,sha256=06NvgUQMzPb2b2mrxtVo7xribZEDQM1LdcXNJdiOfPc,4391
+tests/test_workflow.py,sha256=TmNBxBqSW5owk_Nz9LLtHvqryVNsFPkf-M1G_uFSsAM,3739
 vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
 vectara_agentic/_callback.py,sha256=DMExGJPiZPowB0gL7Re_3406BHg75go1cgzetfGb-KQ,13074
 vectara_agentic/_observability.py,sha256=iZlByeQTyx6g3Y8aBYcdGcxdRkoYrfxHdcrTEKO26UE,4485
-vectara_agentic/_prompts.py,sha256=WryFU4c8qU8UC6py89IGv4cDLkmRlLuePgmw_urqV2s,9966
-vectara_agentic/_version.py,sha256=Zh3DIfvKlagqgNm3zicMbpxhbyEwI1XKWQh3ECIkiOI,66
-vectara_agentic/agent.py,sha256=zJ7ucFf8jc0VO4mTFqujfwREz2B-rJCpIgCJKAtNlEk,54884
+vectara_agentic/_prompts.py,sha256=NbKloHQYc25IvtpxmPdRKHXIM-p-lAK-jyk41iafL60,10050
+vectara_agentic/_version.py,sha256=_HryRNoBbJs5TpiuE6yWSRf90S1J6zt4RlW3hL6aslM,66
+vectara_agentic/agent.py,sha256=M4hiHfrVBYIdknI5JMHezabF1QcM1jfHSCx2VXoVTQ4,55912
 vectara_agentic/agent_config.py,sha256=E-rtYMcpoGxnEAyy8231bizo2n0uGQ2qWxuSgTEfwdQ,4327
 vectara_agentic/agent_endpoint.py,sha256=PzIN7HhEHv8Mq_Zo5cZ2xYrgdv2AN6kx6dc_2AJq28I,7497
 vectara_agentic/db_tools.py,sha256=Kfz6n-rSj5TQEbAiJnWGmqWtcwB0A5GpxD7d1UwGzlc,11194
-vectara_agentic/llm_utils.py,sha256=8epayLfyGYX7nAxENMYaOQN7u2fmwESpL9JIF_c0T0o,5902
-vectara_agentic/sub_query_workflow.py,sha256=cPeossVPFajpSAwy45fSXhTXbQOfzv_l66pxSa4molM,12366
+vectara_agentic/llm_utils.py,sha256=oYm2S_xBCacN6GmFr_ASMIKEtRy2z2EQ_qDBfgSpiWE,7247
+vectara_agentic/sub_query_workflow.py,sha256=JYwN0wK4QzHjTaFDsSCAQvMx9GD4g6CnqxZCnzi6xb4,13086
 vectara_agentic/tool_utils.py,sha256=FkwKY2IsMHXIb-uD-wef8vVB_eZKkReeb74CcXGo1cQ,19219
-vectara_agentic/tools.py,sha256=RahCvqF0LvcSnbyEKMr6_LvskrDDmyxtQpqDjWaSvxo,33334
+vectara_agentic/tools.py,sha256=JIHPk08obKtQ4s6bhVYyyi82U7X5WaxEOxju6L_eej8,33519
 vectara_agentic/tools_catalog.py,sha256=cAN_kDOWZUoW4GNFwY5GdS6ImMUQNnF2sggx9OGK9Cg,4906
 vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
 vectara_agentic/utils.py,sha256=R9HitEG5K3Q_p2M_teosT181OUxkhs1-hnj98qDYGbE,2545
-vectara_agentic-0.2.21.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.21.dist-info/METADATA,sha256=6bLcoqmUhy8M4gSgOUCjFivOFO_4oN8Xd8Xz-JXjlh4,30559
-vectara_agentic-0.2.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vectara_agentic-0.2.21.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.21.dist-info/RECORD,,
+vectara_agentic-0.2.23.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.23.dist-info/METADATA,sha256=Hv56Z2BC5nxAT1YrMvr4iXQMUquXg8JYCsEQOXyHrzU,31127
+vectara_agentic-0.2.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vectara_agentic-0.2.23.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.23.dist-info/RECORD,,