vectara-agentic 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

vectara_agentic/sub_query_workflow.py

@@ -60,16 +60,24 @@ class SubQuestionQueryWorkflow(Workflow):
 
         if hasattr(ev, "agent"):
             await ctx.set("agent", ev.agent)
+        else:
+            raise ValueError("Agent not provided to workflow Start Event.")
         chat_history = [str(msg) for msg in ev.agent.memory.get()]
 
         if hasattr(ev, "llm"):
             await ctx.set("llm", ev.llm)
+        else:
+            raise ValueError("LLM not provided to workflow Start Event.")
 
         if hasattr(ev, "tools"):
             await ctx.set("tools", ev.tools)
+        else:
+            raise ValueError("Tools not provided to workflow Start Event.")
 
         if hasattr(ev, "verbose"):
             await ctx.set("verbose", ev.verbose)
+        else:
+            await ctx.set("verbose", False)
 
         llm = await ctx.get("llm")
         response = llm.complete(
@@ -77,6 +85,7 @@ class SubQuestionQueryWorkflow(Workflow):
             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 will answer the question.
+            Order the sub-questions in the right order if there are dependencies.
             Make sure sub-questions do not result in duplicate tool calling.
             Respond in pure JSON without any markdown, like this:
             {{
@@ -106,11 +115,11 @@ class SubQuestionQueryWorkflow(Workflow):
         await ctx.set("sub_question_count", len(sub_questions))
 
         for question in sub_questions:
-            self.send_event(self.QueryEvent(question=question))
+            ctx.send_event(self.QueryEvent(question=question))
 
         return None
 
-    @step
+    @step(num_workers=3)
     async def sub_question(self, ctx: Context, ev: QueryEvent) -> AnswerEvent:
         """
         Given a sub-question, return the answer to the sub-question, using the agent.
@@ -151,7 +160,6 @@ class SubQuestionQueryWorkflow(Workflow):
             Sub-questions and answers:
             {answers}
         """
-
         if await ctx.get("verbose"):
             print(f"Final prompt is {prompt}")
 
@@ -163,3 +171,134 @@ class SubQuestionQueryWorkflow(Workflow):
 
         output = self.OutputsModel(response=str(response))
         return StopEvent(result=output)
+
+class SequentialSubQuestionsWorkflow(Workflow):
+    """
+    Workflow for breaking a query into sequential sub-questions
+    """
+
+    # Workflow inputs/outputs
+    class InputsModel(BaseModel):
+        """
+        Inputs for the workflow.
+        """
+        query: str
+
+    class OutputsModel(BaseModel):
+        """
+        Outputs for the workflow.
+        """
+        response: str
+
+    # Workflow Event types
+    class QueryEvent(Event):
+        """Event for a query."""
+        question: str
+        prev_answer: str
+        num: int
+
+    @step
+    async def query(self, ctx: Context, ev: StartEvent) -> QueryEvent:
+        """
+        Given a user question, and a list of tools, output a list of relevant
+        sub-questions, such that each question depends on the response of the
+        previous question, to answer the original user question.
+        """
+        if not hasattr(ev, "inputs"):
+            raise ValueError("No inputs provided to workflow Start Event.")
+        if hasattr(ev, "inputs") and not isinstance(ev.inputs, self.InputsModel):
+            raise ValueError(f"Expected inputs to be of type {self.InputsModel}")
+        if hasattr(ev, "inputs"):
+            query = ev.inputs.query
+            await ctx.set("original_query", query)
+
+        if hasattr(ev, "agent"):
+            await ctx.set("agent", ev.agent)
+        else:
+            raise ValueError("Agent not provided to workflow Start Event.")
+        chat_history = [str(msg) for msg in ev.agent.memory.get()]
+
+        if hasattr(ev, "llm"):
+            await ctx.set("llm", ev.llm)
+        else:
+            raise ValueError("LLM not provided to workflow Start Event.")
+
+        if hasattr(ev, "tools"):
+            await ctx.set("tools", ev.tools)
+        else:
+            raise ValueError("Tools not provided to workflow Start Event.")
+
+        if hasattr(ev, "verbose"):
+            await ctx.set("verbose", ev.verbose)
+        else:
+            await ctx.set("verbose", False)
+        if ev.verbose:
+            print(f"Query is {await ctx.get('original_query')}")
+
+        llm = await ctx.get("llm")
+        response = llm.complete(
+            f"""
+            Given a user question, and a list of tools, output a list of
+            relevant sequential sub-questions, such that the answers to all the
+            sub-questions in sequence will answer the question, and the output
+            of each question can be used as input to the subsequent question.
+            Respond in pure JSON without any markdown, like this:
+            {{
+                "sub_questions": [
+                    "What is the population of San Francisco?",
+                    "Is that population larger than the population of San Jose?",
+                ]
+            }}
+            As an example, for the question
+            "what is the name of the mayor of the largest city within 50 miles of San Francisco?",
+            the sub-questions could be:
+            - What is the largest city within 50 miles of San Francisco?
+            - Who is the mayor of this city?
+            The answer to the first question is San Jose, which is given as context to the second question.
+            The answer to the second question is Matt Mahan.
+            Here is the user question: {await ctx.get('original_query')}.
+            Here are previous chat messages: {chat_history}.
+            And here is the list of tools: {await ctx.get('tools')}
+            """,
+        )
+
+        response_obj = json.loads(str(response))
+        sub_questions = response_obj["sub_questions"]
+
+        await ctx.set("sub_questions", sub_questions)
+        if await ctx.get("verbose"):
+            print(f"Sub-questions are {sub_questions}")
+
+        return self.QueryEvent(question=sub_questions[0], prev_answer="", num=0)
+
+    @step
+    async def sub_question(self, ctx: Context, ev: QueryEvent) -> StopEvent | QueryEvent:
+        """
+        Given a sub-question, return the answer to the sub-question, using the agent.
+        """
+        if await ctx.get("verbose"):
+            print(f"Sub-question is {ev.question}")
+        agent = await ctx.get("agent")
+        sub_questions = await ctx.get("sub_questions")
+        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}'
+            """
+            response = await agent.achat(prompt)
+        else:
+            response = await agent.achat(ev.question)
+        if await ctx.get("verbose"):
+            print(f"Answer is {response}")
+
+        sub_questions = await ctx.get("sub_questions")
+        if ev.num + 1 < len(sub_questions):
+            return self.QueryEvent(
+                question=sub_questions[ev.num + 1],
+                prev_answer = response.response,
+                num=ev.num + 1
+            )
+
+        output = self.OutputsModel(response=response.response)
+        return StopEvent(result=output)

vectara_agentic/tools.py

@@ -8,7 +8,7 @@ import importlib
 import os
 
 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
@@ -21,7 +21,7 @@ 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 .utils import is_float, summarize_vectara_document
 from .agent_config import AgentConfig
 
 LI_packages = {
@@ -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.
@@ -161,7 +162,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 +172,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 +256,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."
             )
 
@@ -320,6 +380,8 @@ class VectaraToolFactory:
         self.vectara_corpus_key = vectara_corpus_key
         self.vectara_api_key = vectara_api_key
         self.num_corpora = len(vectara_corpus_key.split(","))
+        self.cache_expiry = 60 * 60  # 1 hour
+        self.max_cache_size = 128
 
     def create_search_tool(
         self,
@@ -392,7 +454,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.
             """
@@ -404,6 +466,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:
@@ -451,7 +514,11 @@ class VectaraToolFactory:
                 if doc.id_ in unique_ids:
                     continue
                 unique_ids.add(doc.id_)
-                tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n"
+                if summarize:
+                    summary = summarize_vectara_document(self.vectara_corpus_key, self.vectara_api_key, doc.id_)
+                    tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\nsummary: '{summary}'\n\n"
+                else:
+                    tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n\n"
             out = ToolOutput(
                 tool_name=search_function.__name__,
                 content=tool_output,
@@ -460,42 +527,22 @@ 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, default=10, 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" + """
+        The response includes metadata about each relevant document.
+        If summarize=True, it also includes a summary of each document.
         """
-        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
 
@@ -595,11 +642,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.
             """
@@ -719,39 +766,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
 

vectara_agentic/types.py

@@ -12,6 +12,7 @@ class AgentType(Enum):
 
     REACT = "REACT"
     OPENAI = "OPENAI"
+    FUNCTION_CALLING = "FUNCTION_CALLING"
     LLMCOMPILER = "LLMCOMPILER"
     LATS = "LATS"
 
@@ -57,6 +58,11 @@ class ToolType(Enum):
     QUERY = "query"
     ACTION = "action"
 
+class AgentConfigType(Enum):
+    """Enumeration for different types of agent configurations."""
+    DEFAULT = "default"
+    FALLBACK = "fallback"
+
 
 # classes for Agent responses
 ToolOutput = LI_ToolOutput

vectara_agentic/utils.py

@@ -5,6 +5,8 @@ Utilities for the Vectara agentic.
 from typing import Tuple, Callable, Optional
 from functools import lru_cache
 from inspect import signature
+import json
+import requests
 
 import tiktoken
 
@@ -17,13 +19,13 @@ from .agent_config import AgentConfig
 
 provider_to_default_model_name = {
     ModelProvider.OPENAI: "gpt-4o",
-    ModelProvider.ANTHROPIC: "claude-3-5-sonnet-20241022",
+    ModelProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
     ModelProvider.TOGETHER: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
     ModelProvider.GROQ: "llama-3.3-70b-versatile",
     ModelProvider.FIREWORKS: "accounts/fireworks/models/firefunction-v2",
     ModelProvider.BEDROCK: "anthropic.claude-3-5-sonnet-20241022-v2:0",
     ModelProvider.COHERE: "command-r-plus",
-    ModelProvider.GEMINI: "models/gemini-1.5-flash",
+    ModelProvider.GEMINI: "models/gemini-2.0-flash",
 }
 
 DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
@@ -90,35 +92,50 @@ 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)
     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 +158,25 @@ def remove_self_from_signature(func):
     new_sig = sig.replace(parameters=params)
     func.__signature__ = new_sig
     return func
+
+def summarize_vectara_document(corpus_key: str, vectara_api_key, 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
+    }
+
+    response = requests.request("POST", url, headers=headers, data=payload, timeout=60)
+    if response.status_code != 200:
+        return f"Vectara Summarization failed with error code {response.status_code}, error={response.text}"
+    return json.loads(response.text)["summary"]

{vectara_agentic-0.2.5.dist-info → vectara_agentic-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.5
+Version: 0.2.7
 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
@@ -41,18 +41,18 @@ Requires-Dist: llama-index-tools-exa==0.3.0
 Requires-Dist: tavily-python==0.5.1
 Requires-Dist: exa-py==1.8.9
 Requires-Dist: yahoo-finance==1.4.0
-Requires-Dist: openinference-instrumentation-llama-index==3.1.4
-Requires-Dist: opentelemetry-proto==1.26.0
-Requires-Dist: arize-phoenix==7.11.0
-Requires-Dist: arize-phoenix-otel==0.6.1
-Requires-Dist: protobuf==4.25.5
+Requires-Dist: openinference-instrumentation-llama-index==3.3.3
+Requires-Dist: opentelemetry-proto==1.31.0
+Requires-Dist: arize-phoenix==8.14.1
+Requires-Dist: arize-phoenix-otel==0.8.0
+Requires-Dist: protobuf==5.29.3
 Requires-Dist: tokenizers>=0.20
-Requires-Dist: pydantic==2.10.3
+Requires-Dist: pydantic==2.10.6
 Requires-Dist: retrying==1.3.4
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: tiktoken==0.9.0
 Requires-Dist: cloudpickle>=3.1.1
-Requires-Dist: httpx==0.27.2
+Requires-Dist: httpx==0.28.1
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -60,6 +60,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python

vectara_agentic-0.2.7.dist-info/RECORD

@@ -0,0 +1,28 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/endpoint.py,sha256=frnpdZQpnuQNNKNYgAn2rFTarNG8MCJaNA77Bw_W22A,1420
+tests/test_agent.py,sha256=CU7Zdb1J5kFjrkkIeDr70W1wsikYuOvoYKGYpg4EPxM,6678
+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_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=FGUM5lA5uZpmWWB52dt2AMCqWcU0M9b-2BB-raX-EN4,65
+vectara_agentic/agent.py,sha256=nbBl66n56kjEZX4Zconb9IZjESzpjBZIEQdL4uLfurI,43333
+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=eS1S7l5PdyLPLZqxUJSR0oM2kvHb4raPGHk8t8td9sc,10939
+vectara_agentic/tools.py,sha256=RpPGWiPHe-9ZiOxNz389W-gNWxegg7m4RlEx_pH9_W0,42881
+vectara_agentic/tools_catalog.py,sha256=oiw3wAfbpFhh0_6rMvZsyPqWV6QIzHqhZCNzqRxuyV8,4818
+vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
+vectara_agentic/utils.py,sha256=U4VWCyrvpXfPb9SJpd4Xj7rJCN-cZCNReNm9_uQjnlk,6759
+vectara_agentic-0.2.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.7.dist-info/METADATA,sha256=z-IFDKlGmNh9QSIUV4xOOCYKF-PrTUnDukp8M5BNMe4,25046
+vectara_agentic-0.2.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+vectara_agentic-0.2.7.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.7.dist-info/RECORD,,

{vectara_agentic-0.2.5.dist-info → vectara_agentic-0.2.7.dist-info}/WHEEL

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