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

tests/test_api_endpoint.py

@@ -0,0 +1,126 @@
+import unittest
+from uuid import UUID
+
+from fastapi.testclient import TestClient
+
+# Adjust this import to point at the file where you put create_app
+from vectara_agentic.agent_endpoint import create_app
+from vectara_agentic.agent import Agent
+from vectara_agentic.agent_config import AgentConfig
+
+
+class DummyAgent(Agent):
+    def __init__(self):
+        # satisfy Agent.__init__(tools: ...)
+        super().__init__(tools=[])
+
+    def chat(self, message: str) -> str:
+        return f"Echo: {message}"
+
+class APITestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.agent = DummyAgent()
+        # Override only the endpoint_api_key, leave everything else as default
+        cls.config = AgentConfig(endpoint_api_key="testkey")
+        app = create_app(cls.agent, cls.config)
+        cls.client = TestClient(app)
+        cls.headers = {"X-API-Key": cls.config.endpoint_api_key}
+
+    def test_chat_success(self):
+        r = self.client.get("/chat", params={"message": "hello"}, headers=self.headers)
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.json(), {"response": "Echo: hello"})
+
+    def test_chat_empty_message(self):
+        r = self.client.get("/chat", params={"message": ""}, headers=self.headers)
+        self.assertEqual(r.status_code, 400)
+        self.assertIn("No message provided", r.json()["detail"])
+
+    def test_chat_unauthorized(self):
+        r = self.client.get("/chat", params={"message": "hello"}, headers={"X-API-Key": "bad"})
+        self.assertEqual(r.status_code, 403)
+
+    def test_completions_success(self):
+        payload = {"model": "m1", "prompt": "test"}
+        r = self.client.post("/v1/completions", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 200)
+        data = r.json()
+
+        # ID prefix + valid UUID check
+        self.assertTrue(data["id"].startswith("cmpl-"))
+        UUID(data["id"].split("-", 1)[1])
+
+        self.assertEqual(data["model"], "m1")
+        self.assertEqual(data["choices"][0]["text"], "Echo: test")
+        # prompt_tokens=1, completion_tokens=2 ("Echo:", "test")
+        self.assertEqual(data["usage"]["prompt_tokens"], 1)
+        self.assertEqual(data["usage"]["completion_tokens"], 2)
+
+    def test_completions_no_prompt(self):
+        payload = {"model": "m1"}  # missing prompt
+        r = self.client.post("/v1/completions", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 400)
+        self.assertIn("`prompt` is required", r.json()["detail"])
+
+    def test_completions_unauthorized(self):
+        payload = {"model": "m1", "prompt": "hi"}
+        r = self.client.post("/v1/completions", json=payload, headers={"X-API-Key": "bad"})
+        self.assertEqual(r.status_code, 403)
+
+    def test_chat_completion_success(self):
+        payload = {
+            "model": "m1",
+            "messages": [{"role": "user", "content": "hello"}]
+        }
+        r = self.client.post("/v1/chat", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 200)
+        data = r.json()
+
+        # ID prefix + valid UUID check
+        self.assertTrue(data["id"].startswith("chatcmpl-"))
+        UUID(data["id"].split("-", 1)[1])
+
+        self.assertEqual(data["model"], "m1")
+        self.assertEqual(data["choices"][0]["message"]["content"], "Echo: hello")
+
+        # prompt_tokens=1, completion_tokens=2 ("Echo:", "hello")
+        self.assertEqual(data["usage"]["prompt_tokens"], 1)
+        self.assertEqual(data["usage"]["completion_tokens"], 2)
+
+    def test_chat_completion_multiple_user_messages(self):
+        payload = {
+            "model": "m1",
+            "messages": [
+                {"role": "system", "content": "ignore me"},
+                {"role": "user", "content": "foo"},
+                {"role": "assistant", "content": "pong"},
+                {"role": "user", "content": "bar"}
+            ]
+        }
+        r = self.client.post("/v1/chat", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 200)
+        data = r.json()
+
+        # Should concatenate only user messages: "foo bar"
+        self.assertEqual(data["choices"][0]["message"]["content"], "Echo: foo bar")
+        self.assertEqual(data["usage"]["prompt_tokens"], 2)   # "foo","bar"
+        self.assertEqual(data["usage"]["completion_tokens"], 3)  # "Echo:","foo","bar"
+
+    def test_chat_completion_no_messages(self):
+        payload = {"model": "m1", "messages": []}
+        r = self.client.post("/v1/chat", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 400)
+        self.assertIn("`messages` is required", r.json()["detail"])
+
+    def test_chat_completion_unauthorized(self):
+        payload = {
+            "model": "m1",
+            "messages": [{"role": "user", "content": "oops"}]
+        }
+        r = self.client.post("/v1/chat", json=payload, headers={"X-API-Key": "bad"})
+        self.assertEqual(r.status_code, 403)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_gemini.py

@@ -0,0 +1,115 @@
+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.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_gemini = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GEMINI,
+    tool_llm_provider=ModelProvider.GEMINI,
+)
+
+
+class TestGEMINI(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,
+        )
+
+        agent = Agent(
+            tools=[query_tool_1],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 15 arguments",
+            agent_config=fc_config_gemini,
+        )
+        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"])
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_groq.py

@@ -54,13 +54,6 @@ def get_valid_years() -> list[str]:
     return years
 
 
-config_gemini = AgentConfig(
-    agent_type=AgentType.FUNCTION_CALLING,
-    main_llm_provider=ModelProvider.GEMINI,
-    tool_llm_provider=ModelProvider.GEMINI,
-)
-
-
 fc_config_groq = AgentConfig(
     agent_type=AgentType.FUNCTION_CALLING,
     main_llm_provider=ModelProvider.GROQ,

tests/test_tools.py

@@ -251,17 +251,19 @@ class TestToolsPackage(unittest.TestCase):
             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 13 arguments and returns a response (str) to the user query based on the data in this corpus.
+            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,
         )
 
-        # Test with 13 arguments which go over the 1024 limit.
+        # Test with 15 arguments to make sure no issues occur
         config = AgentConfig(
             agent_type=AgentType.OPENAI
         )
@@ -272,9 +274,9 @@ class TestToolsPackage(unittest.TestCase):
             agent_config=config,
         )
         res = agent.chat("What is the stock price for Yahoo on 12/31/22?")
-        self.assertIn("maximum length of 1024 characters", str(res))
+        self.assertNotIn("maximum length of 1024 characters", str(res))
 
-        # Same test but with GROQ
+        # Same test but with GROQ, should not have this limit
         config = AgentConfig(
             agent_type=AgentType.FUNCTION_CALLING,
             main_llm_provider=ModelProvider.GROQ,
@@ -283,13 +285,13 @@ class TestToolsPackage(unittest.TestCase):
         agent = Agent(
             tools=[query_tool_1],
             topic="Sample topic",
-            custom_instructions="Call the tool with 13 arguments for GROQ",
+            custom_instructions="Call the tool with 15 arguments for GROQ",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
         self.assertNotIn("maximum length of 1024 characters", str(res))
 
-        # Same test but with ANTHROPIC
+        # Same test but with ANTHROPIC, should not have this limit
         config = AgentConfig(
             agent_type=AgentType.FUNCTION_CALLING,
             main_llm_provider=ModelProvider.ANTHROPIC,
@@ -298,38 +300,12 @@ class TestToolsPackage(unittest.TestCase):
         agent = Agent(
             tools=[query_tool_1],
             topic="Sample topic",
-            custom_instructions="Call the tool with 13 arguments for ANTHROPIC",
+            custom_instructions="Call the tool with 15 arguments for ANTHROPIC",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
-        # ANTHROPIC does not have that 1024 limit
         self.assertIn("stock price", str(res))
 
-        # But using Compact_docstring=True, we can pass 13 arguments successfully.
-        vec_factory = VectaraToolFactory(
-            vectara_corpus_key, vectara_api_key, compact_docstring=True
-        )
-        query_tool_2 = 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 doesn not crash with OpenAI.
-            """,
-            tool_args_schema=QueryToolArgs,
-        )
-
-        config = AgentConfig()
-        agent = Agent(
-            tools=[query_tool_2],
-            topic="Sample topic",
-            custom_instructions="Call the tool with 15 arguments",
-            agent_config=config,
-        )
-        res = agent.chat("What is the stock price?")
-        self.assertTrue(
-            any(sub in str(res) for sub in ["I don't know", "stock price"])
-        )
-
     def test_public_repo(self):
         vectara_corpus_key = "vectara-docs_1"
         vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"

tests/test_workflow.py

@@ -1,5 +1,9 @@
 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
@@ -62,6 +66,69 @@ class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
         res = await agent.run(inputs=inputs, verbose=True)
         self.assertIn("22", res.response)
 
+class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
+
+    async def test_workflow_failure(self):
+        tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
+        topic = "AI topic"
+        instructions = "You are a helpful AI assistant."
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            agent_config = AgentConfig(),
+            workflow_cls = SubQuestionQueryWorkflow,
+            workflow_timeout = 1
+        )
+
+        inputs = SubQuestionQueryWorkflow.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:
+            self.assertIsInstance(e, WorkflowTimeoutError)
+
+        self.assertIsNone(res)
+
+    async def test_workflow_with_fail_class(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_timeout = 1
+        )
+
+        inputs = SubQuestionQueryWorkflow.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.")
+
 
 if __name__ == "__main__":
     unittest.main()

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.16"
+__version__ = "0.2.18"

vectara_agentic/agent.py

@@ -35,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,
@@ -198,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,
@@ -213,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:
         """
@@ -287,10 +287,10 @@ 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(
@@ -643,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":
         """
@@ -712,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,
@@ -1047,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})."
@@ -1059,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.
@@ -1067,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:
@@ -1079,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
 
@@ -1117,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:
@@ -1171,7 +1193,7 @@ class Agent:
             if data.get("fallback_agent_config")
             else None
         )
-        tools = []
+        tools: list[FunctionTool] = []
 
         for tool_data in data["tools"]:
             query_args_model = None

vectara_agentic/agent_endpoint.py

@@ -1,62 +1,252 @@
 """
-This module contains functions to start the agent behind an API endpoint.
+agent_endpoint.py
 """
+
 import logging
-from fastapi import FastAPI, HTTPException, Depends
+import time
+import uuid
+from typing import Any, List, Literal, Optional, Union
+
+from fastapi import Depends, FastAPI, HTTPException
 from fastapi.security.api_key import APIKeyHeader
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 import uvicorn
 
 from .agent import Agent
 from .agent_config import AgentConfig
 
-api_key_header = APIKeyHeader(name="X-API-Key")
 
 class ChatRequest(BaseModel):
-    """
-    A request model for the chat endpoint.
-    """
+    """Request schema for the /chat endpoint."""
+
     message: str
 
 
+class CompletionRequest(BaseModel):
+    """Request schema for the /v1/completions endpoint."""
+
+    model: str
+    prompt: Optional[Union[str, List[str]]] = None
+    max_tokens: Optional[int] = Field(16, ge=1)
+    temperature: Optional[float] = Field(1.0, ge=0.0, le=2.0)
+    top_p: Optional[float] = Field(1.0, ge=0.0, le=1.0)
+    n: Optional[int] = Field(1, ge=1)
+    stop: Optional[Union[str, List[str]]] = None
+
+
+class Choice(BaseModel):
+    """Choice schema returned in CompletionResponse."""
+
+    text: str
+    index: int
+    logprobs: Optional[Any] = None
+    finish_reason: Literal["stop", "length", "error", None]
+
+
+class CompletionUsage(BaseModel):
+    """Token usage details in CompletionResponse."""
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+class CompletionResponse(BaseModel):
+    """Response schema for the /v1/completions endpoint."""
+
+    id: str
+    object: Literal["text_completion"]
+    created: int
+    model: str
+    choices: List[Choice]
+    usage: CompletionUsage
+
+
+class ChatMessage(BaseModel):
+    """Schema for individual chat messages in ChatCompletionRequest."""
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+
+class ChatCompletionRequest(BaseModel):
+    """Request schema for the /v1/chat endpoint."""
+    model: str
+    messages: List[ChatMessage]
+    temperature: Optional[float] = Field(1.0, ge=0.0, le=2.0)
+    top_p: Optional[float] = Field(1.0, ge=0.0, le=1.0)
+    n: Optional[int] = Field(1, ge=1)
+
+
+class ChatCompletionChoice(BaseModel):
+    """Choice schema returned in ChatCompletionResponse."""
+    index: int
+    message: ChatMessage
+    finish_reason: Literal["stop", "length", "error", None]
+
+
+class ChatCompletionResponse(BaseModel):
+    """Response schema for the /v1/chat endpoint."""
+    id: str
+    object: Literal["chat.completion"]
+    created: int
+    model: str
+    choices: List[ChatCompletionChoice]
+    usage: CompletionUsage
+
+
 def create_app(agent: Agent, config: AgentConfig) -> FastAPI:
     """
-    Create a FastAPI application with a chat endpoint.
+    Create and configure the FastAPI app.
+
+    Args:
+        agent (Agent): The agent instance to handle chat/completion.
+        config (AgentConfig): Configuration containing the API key.
+
+    Returns:
+        FastAPI: Configured FastAPI application.
     """
     app = FastAPI()
     logger = logging.getLogger("uvicorn.error")
     logging.basicConfig(level=logging.INFO)
-    endpoint_api_key = config.endpoint_api_key
 
-    @app.get("/chat", summary="Chat with the agent")
-    async def chat(message: str, api_key: str = Depends(api_key_header)):
-        logger.info(f"Received message: {message}")
-        if api_key != endpoint_api_key:
-            logger.warning("Unauthorized access attempt")
+    api_key_header = APIKeyHeader(name="X-API-Key")
+
+    async def _verify_api_key(api_key: str = Depends(api_key_header)):
+        """
+        Dependency that verifies the X-API-Key header.
+
+        Raises:
+            HTTPException(403): If the provided key does not match.
+
+        Returns:
+            bool: True if key is valid.
+        """
+        if api_key != config.endpoint_api_key:
             raise HTTPException(status_code=403, detail="Unauthorized")
+        return True
+
+    @app.get(
+        "/chat", summary="Chat with the agent", dependencies=[Depends(_verify_api_key)]
+    )
+    async def chat(message: str):
+        """
+        Handle GET /chat requests.
 
+        Args:
+            message (str): The user's message to the agent.
+
+        Returns:
+            dict: Contains the agent's response under 'response'.
+
+        Raises:
+            HTTPException(400): If message is empty.
+            HTTPException(500): On internal errors.
+        """
         if not message:
-            logger.error("No message provided in the request")
             raise HTTPException(status_code=400, detail="No message provided")
+        try:
+            res = agent.chat(message)
+            return {"response": res}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail="Internal server error") from e
+
+    @app.post(
+        "/v1/completions",
+        response_model=CompletionResponse,
+        dependencies=[Depends(_verify_api_key)],
+    )
+    async def completions(req: CompletionRequest):
+        """
+        Handle POST /v1/completions requests.
+
+        Args:
+            req (CompletionRequest): The completion request payload.
+
+        Returns:
+            CompletionResponse: The generated completion and usage stats.
+
+        Raises:
+            HTTPException(400): If prompt is missing.
+            HTTPException(500): On internal errors.
+        """
+        if not req.prompt:
+            raise HTTPException(status_code=400, detail="`prompt` is required")
+        raw = req.prompt if isinstance(req.prompt, str) else req.prompt[0]
+        try:
+            start = time.time()
+            text = agent.chat(raw)
+            logger.info(f"Agent returned in {time.time()-start:.2f}s")
+        except Exception as e:
+            raise HTTPException(status_code=500, detail="Internal server error") from e
+
+        p_tokens = len(raw.split())
+        c_tokens = len(text.split())
+
+        return CompletionResponse(
+            id=f"cmpl-{uuid.uuid4()}",
+            object="text_completion",
+            created=int(time.time()),
+            model=req.model,
+            choices=[Choice(text=text, index=0, logprobs=None, finish_reason="stop")],
+            usage=CompletionUsage(
+                prompt_tokens=p_tokens,
+                completion_tokens=c_tokens,
+                total_tokens=p_tokens + c_tokens,
+            ),
+        )
+
+    @app.post(
+        "/v1/chat",
+        response_model=ChatCompletionResponse,
+        dependencies=[Depends(_verify_api_key)],
+    )
+    async def chat_completion(req: ChatCompletionRequest):
+        if not req.messages:
+            raise HTTPException(status_code=400, detail="`messages` is required")
+
+        # concatenate all user messages into a single prompt
+        raw = " ".join(m.content for m in req.messages if m.role == "user")
 
         try:
-            response = agent.chat(message)
-            logger.info(f"Generated response: {response}")
-            return {"response": response}
+            start = time.time()
+            text = agent.chat(raw)
+            logger.info(f"Agent returned in {time.time()-start:.2f}s")
         except Exception as e:
-            logger.error(f"Error during agent processing: {e}")
             raise HTTPException(status_code=500, detail="Internal server error") from e
 
+        p_tokens = len(raw.split())
+        c_tokens = len(text.split())
+
+        return ChatCompletionResponse(
+            id=f"chatcmpl-{uuid.uuid4()}",
+            object="chat.completion",
+            created=int(time.time()),
+            model=req.model,
+            choices=[
+                ChatCompletionChoice(
+                    index=0,
+                    message=ChatMessage(role="assistant", content=text),
+                    finish_reason="stop",
+                )
+            ],
+            usage=CompletionUsage(
+                prompt_tokens=p_tokens,
+                completion_tokens=c_tokens,
+                total_tokens=p_tokens + c_tokens,
+            ),
+        )
+
     return app
 
 
-def start_app(agent: Agent, host='0.0.0.0', port=8000):
+def start_app(agent: Agent, host="0.0.0.0", port=8000):
     """
-    Start the FastAPI server.
+    Launch the FastAPI application using Uvicorn.
 
     Args:
-        host (str, optional): The host address for the API. Defaults to '127.0.0.1'.
-        port (int, optional): The port for the API. Defaults to 8000.
+        agent (Agent): The agent instance for request handling.
+        host (str, optional): Host interface. Defaults to "0.0.0.0".
+        port (int, optional): Port number. Defaults to 8000.
     """
     app = create_app(agent, config=AgentConfig())
     uvicorn.run(app, host=host, port=port)

vectara_agentic/llm_utils.py

@@ -1,7 +1,6 @@
 """
 Utilities for the Vectara agentic.
 """
-from types import MethodType
 from typing import Tuple, Callable, Optional
 from functools import lru_cache
 import tiktoken
@@ -12,7 +11,6 @@ from llama_index.llms.anthropic import Anthropic
 
 from .types import LLMRole, AgentType, ModelProvider
 from .agent_config import AgentConfig
-from .tool_utils import _updated_openai_prepare_chat_with_tools
 
 provider_to_default_model_name = {
     ModelProvider.OPENAI: "gpt-4o",
@@ -124,11 +122,6 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             is_function_calling_model=True,
             max_tokens=max_tokens,
         )
-        # pylint: disable=protected-access
-        llm._prepare_chat_with_tools = MethodType(
-            _updated_openai_prepare_chat_with_tools,
-            llm,
-        )
     elif model_provider == ModelProvider.GROQ:
         from llama_index.llms.groq import Groq
 
@@ -138,11 +131,6 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             is_function_calling_model=True,
             max_tokens=max_tokens,
         )
-        # pylint: disable=protected-access
-        llm._prepare_chat_with_tools = MethodType(
-            _updated_openai_prepare_chat_with_tools,
-            llm,
-        )
     elif model_provider == ModelProvider.FIREWORKS:
         from llama_index.llms.fireworks import Fireworks
 
@@ -167,11 +155,6 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             api_key=config.private_llm_api_key,
             max_tokens=max_tokens,
         )
-        # pylint: disable=protected-access
-        llm._prepare_chat_with_tools = MethodType(
-            _updated_openai_prepare_chat_with_tools,
-            llm,
-        )
 
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")

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:

vectara_agentic/tool_utils.py

@@ -7,7 +7,7 @@ import re
 
 from typing import (
     Callable, List, Dict, Any, Optional, Union, Type, Tuple,
-    Sequence, get_origin, get_args
+    get_origin, get_args
 )
 from pydantic import BaseModel, create_model
 from pydantic_core import PydanticUndefined
@@ -17,52 +17,10 @@ from llama_index.core.tools.function_tool import AsyncCallable
 from llama_index.core.tools.types import ToolMetadata, ToolOutput
 from llama_index.core.workflow.context import Context
 
-from llama_index.core.tools.types import BaseTool
-from llama_index.core.base.llms.types import ChatMessage, MessageRole
-from llama_index.llms.openai.utils import resolve_tool_choice
-
 from .types import ToolType
 from .utils import is_float
 
 
-def _updated_openai_prepare_chat_with_tools(
-    self,
-    tools: Sequence["BaseTool"],
-    user_msg: Optional[Union[str, ChatMessage]] = None,
-    chat_history: Optional[List[ChatMessage]] = None,
-    verbose: bool = False,
-    allow_parallel_tool_calls: bool = False,
-    tool_choice: Union[str, dict] = "auto",
-    strict: Optional[bool] = None,
-    **kwargs: Any,
-) -> Dict[str, Any]:
-    """Predict and call the tool."""
-    tool_specs = [tool.metadata.to_openai_tool(skip_length_check=True) for tool in tools]
-
-    # if strict is passed in, use, else default to the class-level attribute, else default to True`
-    strict = strict if strict is not None else self.strict
-
-    if self.metadata.is_function_calling_model:
-        for tool_spec in tool_specs:
-            if tool_spec["type"] == "function":
-                tool_spec["function"]["strict"] = strict
-                # in current openai 1.40.0 it is always false.
-                tool_spec["function"]["parameters"]["additionalProperties"] = False
-
-    if isinstance(user_msg, str):
-        user_msg = ChatMessage(role=MessageRole.USER, content=user_msg)
-
-    messages = chat_history or []
-    if user_msg:
-        messages.append(user_msg)
-
-    return {
-        "messages": messages,
-        "tools": tool_specs or None,
-        "tool_choice": resolve_tool_choice(tool_choice) if tool_specs else None,
-        **kwargs,
-    }
-
 class VectaraToolMetadata(ToolMetadata):
     """
     A subclass of ToolMetadata adding the tool_type attribute.
@@ -112,6 +70,7 @@ class VectaraTool(FunctionTool):
         tool_metadata: Optional[ToolMetadata] = None,
         callback: Optional[Callable[[Any], Any]] = None,
         async_callback: Optional[AsyncCallable] = None,
+        partial_params: Optional[Dict[str, Any]] = None,
         tool_type: ToolType = ToolType.QUERY,
     ) -> "VectaraTool":
         tool = FunctionTool.from_defaults(
@@ -124,6 +83,7 @@ class VectaraTool(FunctionTool):
             tool_metadata,
             callback,
             async_callback,
+            partial_params
         )
         vectara_tool = cls(
             tool_type=tool_type,

vectara_agentic/tools.py

@@ -36,6 +36,8 @@ LI_packages = {
     "bing_search": ToolType.QUERY,
     "neo4j": ToolType.QUERY,
     "kuzu": ToolType.QUERY,
+    "waii": ToolType.QUERY,
+    "salesforce": ToolType.QUERY,
     "wikipedia": ToolType.QUERY,
     "google": {
         "GmailToolSpec": {

vectara_agentic/utils.py

@@ -68,7 +68,7 @@ async def summarize_documents(
     api_key: str,
     doc_ids: list[str],
     llm_name: str = "gpt-4o",
-) -> dict[str, str]:
+) -> dict[str, str | BaseException]:
     """
     Summarize multiple documents in a Vectara corpus using the Vectara API.
     """

{vectara_agentic-0.2.16.dist-info → vectara_agentic-0.2.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.16
+Version: 0.2.18
 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
@@ -16,12 +16,13 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: llama-index==0.12.34
+Requires-Dist: llama-index==0.12.35
 Requires-Dist: llama-index-indices-managed-vectara==0.4.5
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0
-Requires-Dist: llama-index-agent-openai==0.4.7
-Requires-Dist: llama-index-llms-openai==0.3.38
+Requires-Dist: llama-index-agent-openai==0.4.8
+Requires-Dist: llama-index-llms-openai==0.3.42
+Requires-Dist: llama-index-llms-openai-like>=0.3.5
 Requires-Dist: llama-index-llms-anthropic==0.6.10
 Requires-Dist: llama-index-llms-together==0.3.1
 Requires-Dist: llama-index-llms-groq==0.3.1
@@ -36,15 +37,17 @@ Requires-Dist: llama-index-tools-google==0.3.0
 Requires-Dist: llama-index-tools-tavily_research==0.3.0
 Requires-Dist: llama_index.tools.brave_search==0.3.0
 Requires-Dist: llama-index-tools-neo4j==0.3.0
+Requires-Dist: llama-index-tools-waii==0.3.0
 Requires-Dist: llama-index-graph-stores-kuzu==0.7.0
+Requires-Dist: llama-index-tools-salesforce==0.3.0
 Requires-Dist: llama-index-tools-slack==0.3.0
 Requires-Dist: llama-index-tools-exa==0.3.0
 Requires-Dist: llama-index-tools-wikipedia==0.3.0
 Requires-Dist: llama-index-tools-bing-search==0.3.0
-Requires-Dist: tavily-python==0.5.4
-Requires-Dist: exa-py==1.12.0
+Requires-Dist: tavily-python==0.7.2
+Requires-Dist: exa-py==1.12.1
 Requires-Dist: openinference-instrumentation-llama-index==4.2.1
-Requires-Dist: opentelemetry-proto==1.32.1
+Requires-Dist: opentelemetry-proto>=1.31.0
 Requires-Dist: arize-phoenix==8.26.1
 Requires-Dist: arize-phoenix-otel==0.9.2
 Requires-Dist: protobuf==5.29.3
@@ -365,51 +368,92 @@ vectara-agentic includes various other tools from LlamaIndex ToolSpecs:
   * Tavily Search: Real-time web search using [Tavily API](https://tavily.com/)
     ```python
     from vectara_agentic.tools_catalog import ToolsCatalog
-    tavily_tool = ToolsCatalog(agent_config).tavily_search
+    tools_factory = ToolsFactory()
+    tavily_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="tavily_research",
+                    tool_spec_name="TavilyToolSpec",
+                    api_key=str(os.environ["TAVILY_API_KEY"]),
+                )
     ```
   * EXA.AI: Advanced web search and data extraction
     ```python
-    exa_tool = ToolsCatalog(agent_config).exa_search
+    exa_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="exa.ai",
+                    tool_spec_name="ExaToolSpec",
+                    api_key=str(os.environ["EXA_API_KEY"]),
+                )
     ```
   * Brave Search: Web search using Brave's search engine
     ```python
-    brave_tool = ToolsCatalog(agent_config).brave_search
+    brave_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="brave_search",
+                    tool_spec_name="BraveSearchToolSpec",
+                    api_key=str(os.environ["BRAVE_API_KEY"]),
+                )
     ```
 
 * **Academic Tools**
   * arXiv: Search and retrieve academic papers
     ```python
-    arxiv_tool = ToolsCatalog(agent_config).arxiv_search
+    arxiv_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="arxiv",
+                    tool_spec_name="ArxivToolSpec",
+                )
     ```
 
-* **Graph Database Tools**
+* **Database Tools**
   * Neo4j: Graph database integration
     ```python
-    neo4j_tool = ToolsCatalog(agent_config).neo4j_query
+    neo4j_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="neo4j",
+                    tool_spec_name="Neo4jQueryToolSpec",
+                )
     ```
   * Kuzu: Lightweight graph database
     ```python
-    kuzu_tool = ToolsCatalog(agent_config).kuzu_query
+    kuzu_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="kuzu",
+                    tool_spec_name="KuzuGraphStore",
+                )
+    ```
+  * Waii: tools for natural langauge query of a relational database
+    ```python
+    waii_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="waii",
+                    tool_spec_name="WaiiToolSpec",
+                )
     ```
 
 * **Google Tools**
   * Gmail: Read and send emails
     ```python
-    gmail_tool = ToolsCatalog(agent_config).gmail
+    gmail_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="google",
+                    tool_spec_name="GmailToolSpec",
+                )
     ```
   * Calendar: Manage calendar events
     ```python
-    calendar_tool = ToolsCatalog(agent_config).calendar
+    calendar_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="google",
+                    tool_spec_name="GoogleCalendarToolSpec",
+                )
     ```
   * Search: Google search integration
     ```python
-    google_search_tool = ToolsCatalog(agent_config).google_search
+    search_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="google",
+                    tool_spec_name="GoogleSearchToolSpec",
+                )
     ```
 
 * **Communication Tools**
   * Slack: Send messages and interact with Slack
     ```python
-    slack_tool = ToolsCatalog(agent_config).slack
+    slack_tools = tools_factory.get_llama_index_tools(
+                    tool_package_name="slack",
+                    tool_spec_name="SlackToolSpec",
+                )
     ```
 
 For detailed setup instructions and API key requirements, please refer the instructions on [LlamaIndex hub](https://llamahub.ai/?tab=tools) for the specific tool.

{vectara_agentic-0.2.16.dist-info → vectara_agentic-0.2.18.dist-info}/RECORD

@@ -3,32 +3,34 @@ tests/endpoint.py,sha256=frnpdZQpnuQNNKNYgAn2rFTarNG8MCJaNA77Bw_W22A,1420
 tests/test_agent.py,sha256=o5U3K1AJllsSDvucrgFJPQRdAmHPq3LCuFpsnECUTFk,5483
 tests/test_agent_planning.py,sha256=JwEebGooROAvsQ9JZoaH6KEcrSyv1F0lL4TD4FjP8a8,2213
 tests/test_agent_type.py,sha256=mWo-pTQNDj4fWFPETm5jnb7Y5N48aW35keTVvxdIaCc,7173
+tests/test_api_endpoint.py,sha256=M9YGFCy_Jphzq9JznP4ftHqxZ_yu6dgWdX1jRvdsORA,5002
 tests/test_fallback.py,sha256=M5YD7NHZ0joVU1frYIr9_OiRAIje5mrXrYVcekzlyGs,2829
-tests/test_groq.py,sha256=Knsz-xEBY-eoq8T0DzAC09UJWZqwtLmcjbx6QY37rJg,4235
+tests/test_gemini.py,sha256=QUBYWhZkX9AjnhPn5qa7sREf6YHZWeJEmYzKwVC23Io,4081
+tests/test_groq.py,sha256=5RA6uFC6qra-Do55f6HUotk3EQqOosw0GjOGiHDBS4o,4071
 tests/test_private_llm.py,sha256=CY-_rCpxGUuxnZ3ypkodw5Jj-sJCNdh6rLbCvULwuJI,2247
 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=MWExM3n1oKmVpLmayIgHXqF6_hOPq44KPkRphitBKik,15709
+tests/test_tools.py,sha256=sCgV74LZSRU1zKBhv_emUNe1ZmWIeGVrelNXpd9UV1c,14872
 tests/test_vectara_llms.py,sha256=m-fDAamJR1I5IdV0IpXuTegerTUNCVRm27lsHd4wQjg,2367
-tests/test_workflow.py,sha256=lVyrVHdRO5leYNbYtHTmKqMX0c8_xehCpUA7cXQKVsc,2175
+tests/test_workflow.py,sha256=06NvgUQMzPb2b2mrxtVo7xribZEDQM1LdcXNJdiOfPc,4391
 vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
 vectara_agentic/_callback.py,sha256=ron49t1t-ox-736WaXzrZ99vhN4NI9bMiHFyj0iIPqg,13062
 vectara_agentic/_observability.py,sha256=UbJxiOJFOdLq3b1t0-Y7swMC3BzJu3IOlTUM-c1oUk8,4328
 vectara_agentic/_prompts.py,sha256=vAb02oahA7GKRgLOsDGqgKl-BLBop2AjOlCTgLrf3M4,9694
-vectara_agentic/_version.py,sha256=zjobn8jIz8O5910X5cnrTC2MH3U93-ntXMSx5_WVmW8,66
-vectara_agentic/agent.py,sha256=bHeRh0kug3I8X1wZ73byrrRNfVX3QEXxwTukqAFh0jE,53761
+vectara_agentic/_version.py,sha256=6bWhPhOhATgGaKBsmcgPdRKvZBguw3zZOhD6CJaNJPs,66
+vectara_agentic/agent.py,sha256=zJ7ucFf8jc0VO4mTFqujfwREz2B-rJCpIgCJKAtNlEk,54884
 vectara_agentic/agent_config.py,sha256=E-rtYMcpoGxnEAyy8231bizo2n0uGQ2qWxuSgTEfwdQ,4327
-vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
+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=FOQG6if6D7l1eVRx_r-HSUhh5wBguIaxsYMKrZl2fJo,6302
-vectara_agentic/sub_query_workflow.py,sha256=xjySd2qjLAKwK6XuS0R0PTyk2uXraHCgCbDP1xDoFVI,12175
-vectara_agentic/tool_utils.py,sha256=sB-_UwDi9qNStkDWX_AHIfoxMlTMiWWfTIOBxvHpOkU,20422
-vectara_agentic/tools.py,sha256=hppc2KZ_zMYCiEHsoAS7nMaDgXfAwQZ0b7kyitm95V8,32856
+vectara_agentic/llm_utils.py,sha256=_dkxA9DcBwyIzg-BOTi7NwZZhhjV5G2cnaVlzd9J7do,5687
+vectara_agentic/sub_query_workflow.py,sha256=cPeossVPFajpSAwy45fSXhTXbQOfzv_l66pxSa4molM,12366
+vectara_agentic/tool_utils.py,sha256=jv98vCMYb9afFa-HaPxI2A8BXxplfQRv2Z9b5w7ztZc,18919
+vectara_agentic/tools.py,sha256=2_9YBqszFqYDpvlTIZfdfplRKffe660jQRxp0akM-cE,32918
 vectara_agentic/tools_catalog.py,sha256=cAN_kDOWZUoW4GNFwY5GdS6ImMUQNnF2sggx9OGK9Cg,4906
 vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
-vectara_agentic/utils.py,sha256=q14S8nm3UFFI3ksk-xszd9xgFrtXdIt_tdRiBMFjaa0,2529
-vectara_agentic-0.2.16.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.16.dist-info/METADATA,sha256=vTZeO3QsdOOHAKOJ5CvEmSa67E8DjluaZKxOEq6GgaE,28115
-vectara_agentic-0.2.16.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-vectara_agentic-0.2.16.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.16.dist-info/RECORD,,
+vectara_agentic/utils.py,sha256=R9HitEG5K3Q_p2M_teosT181OUxkhs1-hnj98qDYGbE,2545
+vectara_agentic-0.2.18.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.18.dist-info/METADATA,sha256=FO_4pmBWrl_-7DWPWF32HwOHbbicHdB86YvRi4cA67Y,29946
+vectara_agentic-0.2.18.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+vectara_agentic-0.2.18.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.18.dist-info/RECORD,,

{vectara_agentic-0.2.16.dist-info → vectara_agentic-0.2.18.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any