vectara-agentic 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

vectara_agentic/tools.py

@@ -6,9 +6,10 @@ import inspect
 import re
 import importlib
 import os
+import asyncio
 
 from typing import Callable, List, Dict, Any, Optional, Union, Type
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, create_model
 from pydantic_core import PydanticUndefined
 
 from llama_index.core.tools import FunctionTool
@@ -20,8 +21,8 @@ from llama_index.core.workflow.context import Context
 
 from .types import ToolType
 from .tools_catalog import ToolsCatalog, get_bad_topics
-from .db_tools import DBLoadSampleData, DBLoadUniqueValues, DBLoadData
-from .utils import is_float
+from .db_tools import DatabaseTools
+from .utils import is_float, summarize_documents
 from .agent_config import AgentConfig
 
 LI_packages = {
@@ -31,7 +32,6 @@ LI_packages = {
     "exa": ToolType.QUERY,
     "neo4j": ToolType.QUERY,
     "kuzu": ToolType.QUERY,
-    "database": ToolType.QUERY,
     "google": {
         "GmailToolSpec": {
             "load_data": ToolType.QUERY,
@@ -74,6 +74,7 @@ class VectaraToolMetadata(ToolMetadata):
         base_repr = super().__repr__()
         return f"{base_repr}, tool_type={self.tool_type}"
 
+
 class VectaraTool(FunctionTool):
     """
     A subclass of FunctionTool adding the tool_type attribute.
@@ -108,9 +109,20 @@ class VectaraTool(FunctionTool):
             fn, name, description, return_direct, fn_schema, async_fn, tool_metadata,
             callback, async_callback
         )
-        vectara_tool = cls(tool_type=tool_type, fn=tool.fn, metadata=tool.metadata, async_fn=tool.async_fn)
+        vectara_tool = cls(
+            tool_type=tool_type, fn=tool.fn, metadata=tool.metadata, async_fn=tool.async_fn,
+        )
         return vectara_tool
 
+    def __str__(self) -> str:
+        return (
+            f"Tool(name={self.metadata.name}, "
+            f"Tool metadata={self.metadata})"
+        )
+
+    def __repr__(self) -> str:
+        return str(self)
+
     def __eq__(self, other):
         if not isinstance(other, VectaraTool):
             return False
@@ -161,7 +173,7 @@ class VectaraTool(FunctionTool):
         self, *args: Any, ctx: Optional[Context] = None, **kwargs: Any
     ) -> ToolOutput:
         try:
-            return super().call(*args, ctx=ctx, **kwargs)
+            return await super().acall(*args, ctx=ctx, **kwargs)
         except Exception as e:
             err_output = ToolOutput(
                 tool_name=self.metadata.name,
@@ -171,6 +183,65 @@ class VectaraTool(FunctionTool):
             )
             return err_output
 
+def _create_tool_from_dynamic_function(
+    function: Callable[..., ToolOutput],
+    tool_name: str,
+    tool_description: str,
+    base_params: list[inspect.Parameter],
+    tool_args_schema: type[BaseModel],
+) -> VectaraTool:
+    """
+    Create a VectaraTool from a dynamic function, including
+    setting the function signature and creating the tool schema.
+    """
+    fields = {}
+    for param in base_params:
+        default_value = param.default if param.default != inspect.Parameter.empty else ...
+        fields[param.name] = (param.annotation, default_value)
+    for field_name, field_info in tool_args_schema.model_fields.items():
+        if field_name not in fields:
+            default_value = field_info.default if field_info.default is not PydanticUndefined else ...
+            fields[field_name] = (field_info.annotation, default_value)
+    fn_schema = create_model(f"{tool_name}", **fields)
+
+    schema_params = [
+        inspect.Parameter(
+            name=field_name,
+            kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            default=field_info.default if field_info.default is not PydanticUndefined else inspect.Parameter.empty,
+            annotation=field_info.annotation if hasattr(field_info, 'annotation') else field_info,
+        )
+        for field_name, field_info in tool_args_schema.model_fields.items()
+        if field_name not in [p.name for p in base_params]
+    ]
+    all_params = base_params + schema_params
+
+    required_params = [p for p in all_params if p.default is inspect.Parameter.empty]
+    optional_params = [p for p in all_params if p.default is not inspect.Parameter.empty]
+    sig = inspect.Signature(required_params + optional_params)
+    function.__signature__ = sig
+    function.__annotations__["return"] = dict[str, Any]
+    function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
+
+    # Create the tool function signature string
+    param_strs = []
+    for param in all_params:
+        annotation = param.annotation
+        type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
+        param_strs.append(f"{param.name}: {type_name}")
+    args_str = ", ".join(param_strs)
+    function_str = f"{tool_name}({args_str}) -> str"
+
+    # Create the tool
+    tool = VectaraTool.from_defaults(
+        fn=function,
+        name=tool_name,
+        description=function_str + "\n" + tool_description,
+        fn_schema=fn_schema,
+        tool_type=ToolType.QUERY,
+    )
+    return tool
+
 def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict], fixed_filter: str) -> str:
     """
     Build filter string for Vectara from kwargs
@@ -196,7 +267,7 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
 
         if value is PydanticUndefined:
             raise ValueError(
-                f"Value of argument {key} is undefined, and this is invalid. "
+                f"Value of argument {key} is undefined, and this is invalid."
                 "Please form proper arguments and try again."
             )
 
@@ -394,7 +465,7 @@ class VectaraToolFactory:
         )
 
         # Dynamically generate the search function
-        def search_function(*args, **kwargs) -> ToolOutput:
+        def search_function(*args: Any, **kwargs: Any) -> ToolOutput:
             """
             Dynamically generated function for semantic search Vectara.
             """
@@ -406,6 +477,7 @@ class VectaraToolFactory:
 
             query = kwargs.pop("query")
             top_k = kwargs.pop("top_k", 10)
+            summarize = kwargs.pop("summarize", True)
             try:
                 filter_string = _build_filter_string(kwargs, tool_args_type, fixed_filter)
             except ValueError as e:
@@ -447,13 +519,29 @@ class VectaraToolFactory:
                     raw_input={"args": args, "kwargs": kwargs},
                     raw_output={"response": msg},
                 )
-            tool_output = "Matching documents:\n"
             unique_ids = set()
+            docs = []
             for doc in response:
                 if doc.id_ in unique_ids:
                     continue
                 unique_ids.add(doc.id_)
-                tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n"
+                docs.append((doc.id_, doc.metadata))
+            tool_output = "Matching documents:\n"
+            if summarize:
+                summaries_dict = asyncio.run(
+                    summarize_documents(
+                        self.vectara_corpus_key,
+                        self.vectara_api_key,
+                        list(unique_ids)
+                    )
+                )
+                for doc_id, metadata in docs:
+                    summary = summaries_dict.get(doc_id, "")
+                    tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\nsummary: '{summary}'\n\n"
+            else:
+                for doc in docs:
+                    tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n\n"
+
             out = ToolOutput(
                 tool_name=search_function.__name__,
                 content=tool_output,
@@ -462,42 +550,24 @@ class VectaraToolFactory:
             )
             return out
 
-        fields = tool_args_schema.model_fields
-        params = [
-            inspect.Parameter(
-                name=field_name,
-                kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                default=field_info.default,
-                annotation=field_info,
-            )
-            for field_name, field_info in fields.items()
+        base_params = [
+            inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+            inspect.Parameter("top_k", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+            inspect.Parameter("summarize", inspect.Parameter.POSITIONAL_OR_KEYWORD, default=True, annotation=bool),
         ]
-
-        # Create a new signature using the extracted parameters
-        sig = inspect.Signature(params)
-        search_function.__signature__ = sig
-        search_function.__annotations__["return"] = dict[str, Any]
-        search_function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
-
-        # Create the tool function signature string
-        fields = []
-        for name, field in tool_args_schema.model_fields.items():
-            annotation = field.annotation
-            type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
-            fields.append(f"{name}: {type_name}")
-        args_str = ", ".join(fields)
-        function_str = f"{tool_name}({args_str}) -> str"
-
-        # Create the tool
-        search_tool_extra_desc = """
-        The response includes metadata about each relevant document, but NOT the text itself.
+        search_tool_extra_desc = tool_description + "\n" + """
+        This tool is meant to perform a search for relevant documents, it is not meant for asking questions.
+        The response includes metadata about each relevant document.
+        If summarize=True, it also includes a summary of each document, but takes a lot longer to respond,
+        so avoid using it unless necessary.
         """
-        tool = VectaraTool.from_defaults(
-            fn=search_function,
-            name=tool_name,
-            description=function_str + "\n" + tool_description + '\n' + search_tool_extra_desc,
-            fn_schema=tool_args_schema,
-            tool_type=ToolType.QUERY,
+
+        tool = _create_tool_from_dynamic_function(
+            search_function,
+            tool_name,
+            search_tool_extra_desc,
+            base_params,
+            tool_args_schema,
         )
         return tool
 
@@ -597,11 +667,11 @@ class VectaraToolFactory:
             vectara_corpus_key=self.vectara_corpus_key,
             x_source_str="vectara-agentic",
             vectara_base_url=vectara_base_url,
-            vetara_verify_ssl=vectara_verify_ssl,
+            vectara_verify_ssl=vectara_verify_ssl,
         )
 
         # Dynamically generate the RAG function
-        def rag_function(*args, **kwargs) -> ToolOutput:
+        def rag_function(*args: Any, **kwargs: Any) -> ToolOutput:
             """
             Dynamically generated function for RAG query with Vectara.
             """
@@ -721,39 +791,15 @@ class VectaraToolFactory:
             )
             return out
 
-        fields = tool_args_schema.model_fields
-        params = [
-            inspect.Parameter(
-                name=field_name,
-                kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                default=field_info.default,
-                annotation=field_info,
-            )
-            for field_name, field_info in fields.items()
+        base_params = [
+            inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
         ]
-
-        # Create a new signature using the extracted parameters
-        sig = inspect.Signature(params)
-        rag_function.__signature__ = sig
-        rag_function.__annotations__["return"] = dict[str, Any]
-        rag_function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
-
-        # Create the tool function signature string
-        fields = []
-        for name, field in tool_args_schema.model_fields.items():
-            annotation = field.annotation
-            type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
-            fields.append(f"{name}: {type_name}")
-        args_str = ", ".join(fields)
-        function_str = f"{tool_name}({args_str}) -> str"
-
-        # Create the tool
-        tool = VectaraTool.from_defaults(
-            fn=rag_function,
-            name=tool_name,
-            description=function_str + ". " + tool_description,
-            fn_schema=tool_args_schema,
-            tool_type=ToolType.QUERY,
+        tool = _create_tool_from_dynamic_function(
+            rag_function,
+            tool_name,
+            tool_description,
+            base_params,
+            tool_args_schema,
         )
         return tool
 
@@ -884,7 +930,7 @@ class ToolsFactory:
         user: str = "postgres",
         password: str = "Password",
         dbname: str = "postgres",
-        max_rows: int = 500,
+        max_rows: int = 1000,
     ) -> List[VectaraTool]:
         """
         Returns a list of database tools.
@@ -902,24 +948,16 @@ class ToolsFactory:
             dbname (str, optional): The database name. Defaults to "postgres".
                You must specify either the sql_database object or the scheme, host, port, user, password, and dbname.
             max_rows (int, optional): if specified, instructs the load_data tool to never return more than max_rows
-               rows. Defaults to 500.
+               rows. Defaults to 1000.
 
         Returns:
             List[VectaraTool]: A list of VectaraTool objects.
         """
         if sql_database:
-            tools = self.get_llama_index_tools(
-                tool_package_name="database",
-                tool_spec_name="DatabaseToolSpec",
-                tool_name_prefix=tool_name_prefix,
-                sql_database=sql_database,
-            )
+            dbt = DatabaseTools(sql_database=sql_database)
         else:
             if scheme in ["postgresql", "mysql", "sqlite", "mssql", "oracle"]:
-                tools = self.get_llama_index_tools(
-                    tool_package_name="database",
-                    tool_spec_name="DatabaseToolSpec",
-                    tool_name_prefix=tool_name_prefix,
+                dbt = DatabaseTools(
                     scheme=scheme,
                     host=host,
                     port=port,
@@ -934,28 +972,19 @@ class ToolsFactory:
                 )
 
         # Update tools with description
+        tools = dbt.to_tool_list()
+        vtools = []
         for tool in tools:
             if content_description:
                 tool.metadata.description = (
                     tool.metadata.description + f"The database tables include data about {content_description}."
                 )
-
-        # Add two new tools: load_sample_data and load_unique_values
-        load_data_tool_index = next(i for i, t in enumerate(tools) if t.metadata.name.endswith("load_data"))
-        load_data_fn_original = tools[load_data_tool_index].fn
-
-        load_data_fn = DBLoadData(load_data_fn_original, max_rows=max_rows)
-        load_data_fn.__name__ = f"{tool_name_prefix}_load_data"
-        load_data_tool = self.create_tool(load_data_fn, ToolType.QUERY)
-
-        sample_data_fn = DBLoadSampleData(load_data_fn_original)
-        sample_data_fn.__name__ = f"{tool_name_prefix}_load_sample_data"
-        sample_data_tool = self.create_tool(sample_data_fn, ToolType.QUERY)
-
-        load_unique_values_fn = DBLoadUniqueValues(load_data_fn_original)
-        load_unique_values_fn.__name__ = f"{tool_name_prefix}_load_unique_values"
-        load_unique_values_tool = self.create_tool(load_unique_values_fn, ToolType.QUERY)
-
-        tools[load_data_tool_index] = load_data_tool
-        tools.extend([sample_data_tool, load_unique_values_tool])
-        return tools
+            if len(tool_name_prefix) > 0:
+                tool.metadata.name = tool_name_prefix + "_" + tool.metadata.name
+            vtool = VectaraTool(
+                tool_type=ToolType.QUERY,
+                fn=tool.fn, async_fn=tool.async_fn,
+                metadata=tool.metadata
+            )
+            vtools.append(vtool)
+        return vtools

vectara_agentic/types.py

@@ -12,6 +12,7 @@ class AgentType(Enum):
 
     REACT = "REACT"
     OPENAI = "OPENAI"
+    FUNCTION_CALLING = "FUNCTION_CALLING"
     LLMCOMPILER = "LLMCOMPILER"
     LATS = "LATS"
 

vectara_agentic/utils.py

@@ -5,8 +5,10 @@ Utilities for the Vectara agentic.
 from typing import Tuple, Callable, Optional
 from functools import lru_cache
 from inspect import signature
-
+import json
+import asyncio
 import tiktoken
+import aiohttp
 
 from llama_index.core.llms import LLM
 from llama_index.llms.openai import OpenAI
@@ -90,35 +92,53 @@ def get_llm(
     Get the LLM for the specified role, using the provided config
     or a default if none is provided.
     """
+    max_tokens = 8192
     model_provider, model_name = _get_llm_params_for_role(role, config)
     if model_provider == ModelProvider.OPENAI:
         llm = OpenAI(model=model_name, temperature=0,
                      is_function_calling_model=True,
-                     strict=True)
+                     strict=True,
+                     max_tokens=max_tokens
+            )
     elif model_provider == ModelProvider.ANTHROPIC:
-        llm = Anthropic(model=model_name, temperature=0)
+        llm = Anthropic(
+            model=model_name, temperature=0,
+            max_tokens=max_tokens, cache_idx=2,
+        )
     elif model_provider == ModelProvider.GEMINI:
         from llama_index.llms.gemini import Gemini
-        llm = Gemini(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Gemini(
+            model=model_name, temperature=0,
+            is_function_calling_model=True,
+            max_tokens=max_tokens,
+        )
     elif model_provider == ModelProvider.TOGETHER:
         from llama_index.llms.together import TogetherLLM
-        llm = TogetherLLM(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = TogetherLLM(
+            model=model_name, temperature=0,
+            is_function_calling_model=True,
+            max_tokens=max_tokens
+        )
     elif model_provider == ModelProvider.GROQ:
         from llama_index.llms.groq import Groq
-        llm = Groq(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Groq(
+            model=model_name, temperature=0,
+            is_function_calling_model=True, max_tokens=max_tokens
+        )
     elif model_provider == ModelProvider.FIREWORKS:
         from llama_index.llms.fireworks import Fireworks
-        llm = Fireworks(model=model_name, temperature=0)
+        llm = Fireworks(model=model_name, temperature=0, max_tokens=max_tokens)
     elif model_provider == ModelProvider.BEDROCK:
         from llama_index.llms.bedrock import Bedrock
-        llm = Bedrock(model=model_name, temperature=0)
+        llm = Bedrock(model=model_name, temperature=0, max_tokens=max_tokens)
     elif model_provider == ModelProvider.COHERE:
         from llama_index.llms.cohere import Cohere
-        llm = Cohere(model=model_name, temperature=0)
+        llm = Cohere(model=model_name, temperature=0, max_tokens=max_tokens)
     elif model_provider == ModelProvider.PRIVATE:
         from llama_index.llms.openai_like import OpenAILike
         llm = OpenAILike(model=model_name, temperature=0, is_function_calling_model=True,is_chat_model=True,
-                         api_base=config.private_llm_api_base, api_key=config.private_llm_api_key)
+                         api_base=config.private_llm_api_base, api_key=config.private_llm_api_key,
+                         max_tokens=max_tokens)
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")
     return llm
@@ -141,3 +161,49 @@ def remove_self_from_signature(func):
     new_sig = sig.replace(parameters=params)
     func.__signature__ = new_sig
     return func
+
+async def summarize_vectara_document(corpus_key: str, vectara_api_key: str, doc_id: str) -> str:
+    """
+    Summarize a document in a Vectara corpus using the Vectara API.
+    """
+    url = f"https://api.vectara.io/v2/corpora/{corpus_key}/documents/{doc_id}/summarize"
+
+    payload = json.dumps({
+        "llm_name": "gpt-4o",
+        "model_parameters": {},
+        "stream_response": False
+    })
+    headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'x-api-key': vectara_api_key
+    }
+    timeout = aiohttp.ClientTimeout(total=60)
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        async with session.post(url, headers=headers, data=payload) as response:
+            if response.status != 200:
+                error_json = await response.json()
+                return (
+                    f"Vectara Summarization failed with error code {response.status}, "
+                    f"error={error_json['messages'][0]}"
+                )
+            data = await response.json()
+            return data["summary"]
+    return json.loads(response.text)["summary"]
+
+async def summarize_documents(
+    vectara_corpus_key: str,
+    vectara_api_key: str,
+    doc_ids: list[str]
+) -> dict[str, str]:
+    """
+    Summarize multiple documents in a Vectara corpus using the Vectara API.
+    """
+    if not doc_ids:
+        return {}
+    tasks = [
+        summarize_vectara_document(vectara_corpus_key, vectara_api_key, doc_id)
+        for doc_id in doc_ids
+    ]
+    summaries = await asyncio.gather(*tasks, return_exceptions=True)
+    return dict(zip(doc_ids, summaries))

{vectara_agentic-0.2.6.dist-info → vectara_agentic-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.6
+Version: 0.2.8
 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,7 +16,7 @@ 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.25
+Requires-Dist: llama-index==0.12.26
 Requires-Dist: llama-index-indices-managed-vectara==0.4.2
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0

vectara_agentic-0.2.8.dist-info/RECORD

@@ -0,0 +1,29 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/endpoint.py,sha256=frnpdZQpnuQNNKNYgAn2rFTarNG8MCJaNA77Bw_W22A,1420
+tests/test_agent.py,sha256=t4omKBg9207hpT8b05v9TwuXJCM4knYSTdsXe740eho,4845
+tests/test_agent_planning.py,sha256=_mj73TNP9yUjkUJ-X31r-cQYreJ4qatXOtMrRvVpF4Y,2411
+tests/test_agent_type.py,sha256=JM0Q2GBGHSADoBacz_DW551zWSfbpf7qa8xXqtyWsc4,5671
+tests/test_fallback.py,sha256=M5YD7NHZ0joVU1frYIr9_OiRAIje5mrXrYVcekzlyGs,2829
+tests/test_private_llm.py,sha256=CY-_rCpxGUuxnZ3ypkodw5Jj-sJCNdh6rLbCvULwuJI,2247
+tests/test_serialization.py,sha256=Ed23GN2zhSJNdPFrVK4aqLkOhJKviczR_o0t-r9TuRI,4762
+tests/test_tools.py,sha256=IVKn0HoS2erTCr1mOEGzTkktiY0PCfKNvqnD_pizjOg,3977
+tests/test_workflow.py,sha256=lVyrVHdRO5leYNbYtHTmKqMX0c8_xehCpUA7cXQKVsc,2175
+vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
+vectara_agentic/_callback.py,sha256=5PfqjLmuaZIR6dnqmhniTD_zwCgfi7kOu-nexb6Kss4,9688
+vectara_agentic/_observability.py,sha256=fTL3KW0jQU-_JSpFgjO6-XzgDut_oiq9kt4QR-FkSqU,3804
+vectara_agentic/_prompts.py,sha256=LYyiOAiC8imz3U7MSJiuCYAP39afsp7ycXY7-9biyJI,9314
+vectara_agentic/_version.py,sha256=HOBvs3gmojKxd7sNMHt6Q-0_rlFpgzlI1gXNZOS_Fqc,65
+vectara_agentic/agent.py,sha256=ioC6EN86_d7SS1jEZ6CUe6OtetuGmLdWftj5bklPfMs,43522
+vectara_agentic/agent_config.py,sha256=y1hSvU5ns0cE2R7BqF65LFstixF1ytJcoVgicGXo7w0,3691
+vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
+vectara_agentic/db_tools.py,sha256=Go03bzma9m-qDH0CPP8hWhf1nu_4S6s7ke0jGqz58Pk,10296
+vectara_agentic/sub_query_workflow.py,sha256=3WoVnryR2NXyYXbLDM1XVLd7DtbCG0jgrVqeDUN4YNQ,10943
+vectara_agentic/tools.py,sha256=Mm2qfJZWnbNa9G-ycYMP7NPLSo4uUJ9_y45YmXxtlSc,42571
+vectara_agentic/tools_catalog.py,sha256=oiw3wAfbpFhh0_6rMvZsyPqWV6QIzHqhZCNzqRxuyV8,4818
+vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
+vectara_agentic/utils.py,sha256=nBQqVb4_UNummqVz28DHm3VaKzy8OAq-xSjhU23uxWU,7646
+vectara_agentic-0.2.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.8.dist-info/METADATA,sha256=IV5fm77XOPOvqfcpCZUKRxq9QgnoF3mPu-om_sTKEK8,25046
+vectara_agentic-0.2.8.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+vectara_agentic-0.2.8.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.8.dist-info/RECORD,,

{vectara_agentic-0.2.6.dist-info → vectara_agentic-0.2.8.dist-info}/WHEEL

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

vectara_agentic-0.2.6.dist-info/RECORD

@@ -1,28 +0,0 @@
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/endpoint.py,sha256=frnpdZQpnuQNNKNYgAn2rFTarNG8MCJaNA77Bw_W22A,1420
-tests/test_agent.py,sha256=5iYlROsGQV_fPF9IR1JZ_ByhQ3EoaLG_40ntrCgugWo,6461
-tests/test_agent_planning.py,sha256=0GEI-b7g5tV8xP_FbTfIu-a8J9s_EhDXC_9T6HS6DsU,1457
-tests/test_agent_type.py,sha256=-14Y6vwYTaRJuj8VZ-c6d1vIiWpV31k2zs_frdoxR5s,2920
-tests/test_fallback.py,sha256=4ZqP_7XsabhzaVgXa599PDbwp38t_XY5fMzQwr8F6Z8,2793
-tests/test_private_llm.py,sha256=rPXQ-NKL2MnrMcGNEG1Zz3U8uK9pjxUfjvIl2gH9gnw,2224
-tests/test_tools.py,sha256=0-2oWX8DW0WIjViNFl0xj_6JOhIdyx6zV0IlTuMzxjk,3954
-tests/test_workflow.py,sha256=lVyrVHdRO5leYNbYtHTmKqMX0c8_xehCpUA7cXQKVsc,2175
-vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
-vectara_agentic/_callback.py,sha256=5PfqjLmuaZIR6dnqmhniTD_zwCgfi7kOu-nexb6Kss4,9688
-vectara_agentic/_observability.py,sha256=fTL3KW0jQU-_JSpFgjO6-XzgDut_oiq9kt4QR-FkSqU,3804
-vectara_agentic/_prompts.py,sha256=LYyiOAiC8imz3U7MSJiuCYAP39afsp7ycXY7-9biyJI,9314
-vectara_agentic/_version.py,sha256=EFHZPv0y0xF__sBHhCA8j-o21yOSHXl15GJEp-lZLy4,65
-vectara_agentic/agent.py,sha256=74_2XzBvl5jPyAqqYhoxsS7PXITWBdJpxs4L_XeyZio,42561
-vectara_agentic/agent_config.py,sha256=y1hSvU5ns0cE2R7BqF65LFstixF1ytJcoVgicGXo7w0,3691
-vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
-vectara_agentic/db_tools.py,sha256=VUdcjDFPwauFd2A92mXNYZnCjeMiTzcTka7S5At_3oQ,3595
-vectara_agentic/sub_query_workflow.py,sha256=KcIfUaDcv25n8iLQmZ9ZhNlKyZAKAu-3otXADukBios,10394
-vectara_agentic/tools.py,sha256=xWxl1ixSCsBPjZ-GNpkjN_nXRBxvH_vr8oDauAYrIW0,41763
-vectara_agentic/tools_catalog.py,sha256=oiw3wAfbpFhh0_6rMvZsyPqWV6QIzHqhZCNzqRxuyV8,4818
-vectara_agentic/types.py,sha256=tLpyDY-UbFN2Iqk_fgWoOxlGexh_AQ5BaXQ593sCkRc,1750
-vectara_agentic/utils.py,sha256=AUyWrL8aY67AGx6j9m00k75JRHTI44EAKtal73aMczM,5504
-vectara_agentic-0.2.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.6.dist-info/METADATA,sha256=u9gIGxK3XEPeSItrUevqwJVOWWzRJ3Mqdo55-l3o098,25046
-vectara_agentic-0.2.6.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-vectara_agentic-0.2.6.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.6.dist-info/RECORD,,