vectara-agentic 0.2.24__py3-none-any.whl → 0.3.1__py3-none-any.whl

vectara_agentic/tools.py

@@ -14,7 +14,6 @@ from pydantic import BaseModel, Field
 from llama_index.core.tools import FunctionTool
 from llama_index.indices.managed.vectara import VectaraIndex
 from llama_index.core.utilities.sql_wrapper import SQLDatabase
-from llama_index.core.tools.types import ToolOutput
 
 from .types import ToolType
 from .tools_catalog import ToolsCatalog, get_bad_topics
@@ -25,6 +24,7 @@ from .tool_utils import (
     create_tool_from_dynamic_function,
     build_filter_string,
     VectaraTool,
+    create_human_readable_output,
 )
 
 LI_packages = {
@@ -170,7 +170,7 @@ class VectaraToolFactory:
         )
 
         # Dynamically generate the search function
-        def search_function(*args: Any, **kwargs: Any) -> ToolOutput:
+        def search_function(*args: Any, **kwargs: Any) -> list[dict]:
             """
             Dynamically generated function for semantic search Vectara.
             """
@@ -192,12 +192,11 @@ class VectaraToolFactory:
                     kwargs, tool_args_type, fixed_filter
                 )
             except ValueError as e:
-                return ToolOutput(
-                    tool_name=search_function.__name__,
-                    content=str(e),
-                    raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={"response": str(e)},
+                msg = (
+                    f"Building filter string failed in search tool due to invalid input or configuration ({e}). "
+                    "Please verify the input arguments and ensure they meet the expected format or conditions."
                 )
+                return [{"text": msg, "metadata": {"args": args, "kwargs": kwargs}}]
 
             vectara_retriever = vectara.as_retriever(
                 summary_enabled=False,
@@ -228,12 +227,7 @@ class VectaraToolFactory:
 
             if len(response) == 0:
                 msg = "Vectara Tool failed to retrieve any results for the query."
-                return ToolOutput(
-                    tool_name=search_function.__name__,
-                    content=msg,
-                    raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={"response": msg},
-                )
+                return [{"text": msg, "metadata": {"args": args, "kwargs": kwargs}}]
             unique_ids = set()
             docs = []
             doc_matches = {}
@@ -244,7 +238,8 @@ class VectaraToolFactory:
                 unique_ids.add(doc.id_)
                 doc_matches[doc.id_] = [doc.node.get_content()]
                 docs.append((doc.id_, doc.metadata))
-            tool_output = "Matching documents:\n"
+
+            res = []
             if summarize:
                 summaries_dict = asyncio.run(
                     summarize_documents(
@@ -254,35 +249,45 @@ class VectaraToolFactory:
                         doc_ids=list(unique_ids),
                     )
                 )
-                for doc_id, metadata in docs:
-                    summary = summaries_dict.get(doc_id, "")
-                    matching_text = "\n".join(
-                        f"<match {i}>{piece}</match {i}>"
-                        for i, piece in enumerate(doc_matches[doc_id], start=1)
-                    )
-                    tool_output += (
-                        f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n"
-                        f"matching texts: '{matching_text}'\n"
-                        f"summary: '{summary}'\n\n"
-                    )
             else:
-                for doc_id, metadata in docs:
-                    matching_text = "\n".join(
-                        f"<match {i}>{piece}</match {i}>"
-                        for i, piece in enumerate(doc_matches[doc_id], start=1)
-                    )
-                    tool_output += (
-                        f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n"
-                        f"matching texts: '{matching_text}'\n"
-                    )
+                summaries_dict = {}
+
+            for doc_id, metadata in docs:
+                res.append(
+                    {
+                        "text": summaries_dict.get(doc_id, "") if summarize else "",
+                        "metadata": {
+                            "document_id": doc_id,
+                            "metadata": metadata,
+                            "matching_text": doc_matches[doc_id],
+                        },
+                    }
+                )
 
-            out = ToolOutput(
-                tool_name=search_function.__name__,
-                content=tool_output,
-                raw_input={"args": args, "kwargs": kwargs},
-                raw_output=response,
-            )
-            return out
+            # Create human-readable output using sequential format
+            def format_search_results(results):
+                if not results:
+                    return "No search results found"
+
+                # Create a sequential view for human reading
+                formatted_results = []
+                for i, result in enumerate(results, 1):
+                    result_str = f"**Result #{i}**\n"
+                    result_str += f"Document ID: {result['metadata']['document_id']}\n"
+                    if summarize and result["text"]:
+                        result_str += f"Summary: {result['text']}\n"
+
+                    # Add all matching text if available
+                    matches = result["metadata"]["matching_text"]
+                    if matches:
+                        result_str += ''.join(
+                            f"Match #{inx} Text: {match}\n"
+                            for inx, match in enumerate(matches, 1)
+                        )
+                    formatted_results.append(result_str)
+                return "\n".join(formatted_results)
+
+            return create_human_readable_output(res, format_search_results)
 
         class SearchToolBaseParams(BaseModel):
             """Model for the base parameters of the search tool."""
@@ -362,6 +367,7 @@ class VectaraToolFactory:
         frequency_penalty: Optional[float] = None,
         presence_penalty: Optional[float] = None,
         include_citations: bool = True,
+        citation_pattern: str = "{doc.url}",
         save_history: bool = False,
         fcs_threshold: float = 0.0,
         return_direct: bool = False,
@@ -415,6 +421,9 @@ class VectaraToolFactory:
                 higher values increasing the diversity of topics.
             include_citations (bool, optional): Whether to include citations in the response.
                 If True, uses markdown vectara citations that requires the Vectara scale plan.
+            citation_pattern (str, optional): The pattern for the citations in the response.
+                Default is "{doc.url}" which uses the document URL.
+                If include_citations is False, this parameter is ignored.
             save_history (bool, optional): Whether to save the query in history.
             fcs_threshold (float, optional): A threshold for factual consistency.
                 If set above 0, the tool notifies the calling agent that it "cannot respond" if FCS is too low.
@@ -434,9 +443,10 @@ class VectaraToolFactory:
             vectara_base_url=vectara_base_url,
             vectara_verify_ssl=vectara_verify_ssl,
         )
+        keys_to_ignore = ["lang", "offset", "len"]
 
         # Dynamically generate the RAG function
-        def rag_function(*args: Any, **kwargs: Any) -> ToolOutput:
+        def rag_function(*args: Any, **kwargs: Any) -> dict:
             """
             Dynamically generated function for RAG query with Vectara.
             """
@@ -452,12 +462,12 @@ class VectaraToolFactory:
                     kwargs, tool_args_type, fixed_filter
                 )
             except ValueError as e:
-                return ToolOutput(
-                    tool_name=rag_function.__name__,
-                    content=str(e),
-                    raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={"response": str(e)},
+                msg = (
+                    f"Building filter string failed in rag tool. "
+                    f"Reason: {e}. Ensure that the input arguments match the expected "
+                    f"format and include all required fields. "
                 )
+                return {"text": msg, "metadata": {"args": args, "kwargs": kwargs}}
 
             vectara_query_engine = vectara.as_query_engine(
                 summary_enabled=True,
@@ -491,7 +501,7 @@ class VectaraToolFactory:
                 frequency_penalty=frequency_penalty,
                 presence_penalty=presence_penalty,
                 citations_style="markdown" if include_citations else None,
-                citations_url_pattern="{doc.url}" if include_citations else None,
+                citations_url_pattern=citation_pattern if include_citations else None,
                 save_history=save_history,
                 x_source_str="vectara-agentic",
                 verbose=verbose,
@@ -503,73 +513,67 @@ class VectaraToolFactory:
                     "Tool failed to generate a response since no matches were found. "
                     "Please check the arguments and try again."
                 )
-                return ToolOutput(
-                    tool_name=rag_function.__name__,
-                    content=msg,
-                    raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={"response": msg},
-                )
+                return {"text": msg, "metadata": {"args": args, "kwargs": kwargs}}
             if str(response) == "None":
                 msg = "Tool failed to generate a response."
-                return ToolOutput(
-                    tool_name=rag_function.__name__,
-                    content=msg,
-                    raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={"response": msg},
-                )
+                return {"text": msg, "metadata": {"args": args, "kwargs": kwargs}}
 
             # Extract citation metadata
             pattern = r"\[(\d+)\]"
             matches = re.findall(pattern, response.response)
             citation_numbers = sorted(set(int(match) for match in matches))
-            citation_metadata = ""
-            keys_to_ignore = ["lang", "offset", "len"]
+            citation_metadata = {}
             for citation_number in citation_numbers:
-                metadata = response.source_nodes[citation_number - 1].metadata
-                citation_metadata += (
-                    f"[{citation_number}]: "
-                    + "; ".join(
-                        [
-                            f"{k}='{v}'"
-                            for k, v in metadata.items()
-                            if k not in keys_to_ignore
-                        ]
-                    )
-                    + ".\n"
-                )
+                metadata = {
+                    k: v
+                    for k, v in response.source_nodes[
+                        citation_number - 1
+                    ].metadata.items()
+                    if k not in keys_to_ignore
+                }
+                citation_metadata[str(citation_number)] = metadata
             fcs = 0.0
             fcs_str = response.metadata["fcs"] if "fcs" in response.metadata else "0.0"
             if fcs_str and is_float(fcs_str):
                 fcs = float(fcs_str)
                 if fcs < fcs_threshold:
                     msg = f"Could not answer the query due to suspected hallucination (fcs={fcs})."
-                    return ToolOutput(
-                        tool_name=rag_function.__name__,
-                        content=msg,
-                        raw_input={"args": args, "kwargs": kwargs},
-                        raw_output={"response": msg},
-                    )
-            res = {
-                "response": response.response,
-                "references_metadata": citation_metadata,
-                "fcs_score": fcs,
-            }
-            if len(citation_metadata) > 0:
-                tool_output = f"""
-                    Response: '''{res['response']}'''
-                    fcs_score: {res['fcs_score']:.4f}
-                    References:
-                    {res['references_metadata']}
-                """
-            else:
-                tool_output = f"Response: '''{res['response']}'''"
-            out = ToolOutput(
-                tool_name=rag_function.__name__,
-                content=tool_output,
-                raw_input={"args": args, "kwargs": kwargs},
-                raw_output=res,
-            )
-            return out
+                    return {
+                        "text": msg,
+                        "metadata": {"args": args, "kwargs": kwargs, "fcs": fcs},
+                    }
+            if fcs:
+                citation_metadata["fcs"] = fcs
+            res = {"text": response.response, "metadata": citation_metadata}
+
+            # Create human-readable output with citation formatting
+            def format_rag_response(result):
+                text = result["text"]
+
+                # Format citations if present
+                metadata = result["metadata"]
+                citation_info = []
+                for key, value in metadata.items():
+                    if key.isdigit():
+                        doc = value.get("document", {})
+                        doc_metadata = f"{key}: " + "; ".join(
+                            [
+                                f"{k}='{v}'"
+                                for k, v in doc.items()
+                            ] +
+                            [
+                                f"{k}='{v}'"
+                                for k, v in value.items()
+                                if k not in ["document"] + keys_to_ignore
+                            ]
+                        )
+                        citation_info.append(doc_metadata)
+                if citation_info:
+                    text += "\n\nCitations:\n" + "\n".join(citation_info)
+
+                return text
+
+            return create_human_readable_output(res, format_rag_response)
 
         class RagToolBaseParams(BaseModel):
             """Model for the base parameters of the RAG tool."""

vectara_agentic/types.py

@@ -1,11 +1,17 @@
 """
 This module contains the types used in the Vectara Agentic.
 """
+
 from enum import Enum
+from typing import Protocol, Any
 
+from llama_index.core.schema import Document as LI_Document
 from llama_index.core.tools.types import ToolOutput as LI_ToolOutput
 from llama_index.core.chat_engine.types import AgentChatResponse as LI_AgentChatResponse
-from llama_index.core.chat_engine.types import StreamingAgentChatResponse as LI_StreamingAgentChatResponse
+from llama_index.core.chat_engine.types import (
+    StreamingAgentChatResponse as LI_StreamingAgentChatResponse,
+)
+
 
 class AgentType(Enum):
     """Enumeration for different types of agents."""
@@ -16,6 +22,7 @@ class AgentType(Enum):
     LLMCOMPILER = "LLMCOMPILER"
     LATS = "LATS"
 
+
 class ObserverType(Enum):
     """Enumeration for different types of observability integrations."""
 
@@ -55,16 +62,30 @@ class LLMRole(Enum):
 
 class ToolType(Enum):
     """Enumeration for different types of tools."""
+
     QUERY = "query"
     ACTION = "action"
 
+
 class AgentConfigType(Enum):
     """Enumeration for different types of agent configurations."""
+
     DEFAULT = "default"
     FALLBACK = "fallback"
 
 
+class HumanReadableOutput(Protocol):
+    """Protocol for tool outputs that can provide human-readable representations."""
+
+    def to_human_readable(self) -> str:
+        """Convert the output to a human-readable format."""
+
+    def get_raw_output(self) -> Any:
+        """Get the raw output data."""
+
+
 # classes for Agent responses
 ToolOutput = LI_ToolOutput
 AgentResponse = LI_AgentChatResponse
 AgentStreamingResponse = LI_StreamingAgentChatResponse
+Document = LI_Document

{vectara_agentic-0.2.24.dist-info → vectara_agentic-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.24
+Version: 0.3.1
 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
@@ -49,7 +49,7 @@ Requires-Dist: llama-index-tools-bing-search==0.3.0
 Requires-Dist: openai>=1.82.1
 Requires-Dist: tavily-python==0.7.3
 Requires-Dist: exa-py==1.13.1
-Requires-Dist: openinference-instrumentation-llama-index==4.2.1
+Requires-Dist: openinference-instrumentation-llama-index==4.3.1
 Requires-Dist: opentelemetry-proto>=1.31.0
 Requires-Dist: arize-phoenix==10.9.1
 Requires-Dist: arize-phoenix-otel==0.10.3
@@ -61,6 +61,7 @@ Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: tiktoken==0.9.0
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: httpx==0.28.1
+Requires-Dist: commonmark==0.9.1
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -479,10 +480,32 @@ def mult_func(x, y):
 mult_tool = ToolsFactory().create_tool(mult_func)
 ```
 
+#### Human-Readable Tool Output
+
+Tools can provide both raw data and human-readable formatted output using the `create_human_readable_output` utility:
+
+```python
+from vectara_agentic.tool_utils import create_human_readable_output, format_as_table
+
+def my_data_tool(query: str):
+    """Tool that returns structured data with custom formatting."""
+    raw_data = [
+        {"name": "Alice", "age": 30, "city": "New York"},
+        {"name": "Bob", "age": 25, "city": "Boston"}
+    ]
+    
+    # Return human-readable output with built-in table formatter
+    return create_human_readable_output(raw_data, format_as_table)
+```
+
+Built-in formatters include `format_as_table`, `format_as_json`, and `format_as_markdown_list`. For detailed documentation and advanced usage, see [tools.md](docs/tools.md#human-readable-tool-output).
+
 > **Important:** When you define your own Python functions as tools, implement them at the top module level,
 > and not as nested functions. Nested functions are not supported if you use serialization 
 > (dumps/loads or from_dict/to_dict).
 
+The human-readable format, if available, is used when computing the factual consistency score.
+
 ### Tool Validation
 
 When creating an agent, you can enable tool validation by setting `validate_tools=True`. This will check that any tools mentioned in your custom instructions actually exist in the agent's tool set:

{vectara_agentic-0.2.24.dist-info → vectara_agentic-0.3.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/endpoint.py,sha256=frnpdZQpnuQNNKNYgAn2rFTarNG8MCJaNA77Bw_W22A,1420
-tests/test_agent.py,sha256=BmpJrYN-BLwYasgPhY5Dji-kIpc723e2F6I-nj4EQgc,5510
+tests/test_agent.py,sha256=4aRDhEVM1zARpSOevPR8PFGTkIaSw5g5WvoQDx-4sns,5496
 tests/test_agent_planning.py,sha256=JwEebGooROAvsQ9JZoaH6KEcrSyv1F0lL4TD4FjP8a8,2213
 tests/test_agent_type.py,sha256=9ZImIDw7Qz5EV2tX8bDD0tT1IFYghS3-SShpAezHO7s,7381
 tests/test_api_endpoint.py,sha256=M9YGFCy_Jphzq9JznP4ftHqxZ_yu6dgWdX1jRvdsORA,5002
@@ -8,30 +8,32 @@ tests/test_bedrock.py,sha256=23A5_2FRaEl47PzgfUPDL6dgFDPJ9iktz-A-B1UwIhg,1224
 tests/test_fallback.py,sha256=M5YD7NHZ0joVU1frYIr9_OiRAIje5mrXrYVcekzlyGs,2829
 tests/test_gemini.py,sha256=QUBYWhZkX9AjnhPn5qa7sREf6YHZWeJEmYzKwVC23Io,4081
 tests/test_groq.py,sha256=5yTlOLwpzGRmiBPExAuulK6SEO9O13cMJWVSSHX9CsE,1212
+tests/test_hhem.py,sha256=XFUX3x0xOa9QsafzYNP8_ZsvzIiLnWee4hdsowzHft8,3250
 tests/test_private_llm.py,sha256=-bQBI69Z-SwhhQJGzyC9GGM4kz5c6T5kAbXLbqn_G7E,2248
-tests/test_return_direct.py,sha256=Y_K_v88eS_kJfxE6A0Yghma0nUT8u6COitj0SNnZGNs,1523
+tests/test_return_direct.py,sha256=mgj1xJnvOX28aaidhZfH2DaI-kM0yfQ0P1PNV0iyLcw,1405
 tests/test_serialization.py,sha256=Ed23GN2zhSJNdPFrVK4aqLkOhJKviczR_o0t-r9TuRI,4762
-tests/test_tools.py,sha256=j6wY-jqeerE4Q7lxzuxbftRyzPLHE1scWKNFLgX7wSk,17138
+tests/test_tools.py,sha256=bhhq49I3eEJyuNf5FU7M9IxPT0XtwRbRTs3gwoBHihk,17128
 tests/test_vectara_llms.py,sha256=gw5KQ4XT3L-_A6yj2jKqj-QomCjOb9VESKBtBH2Xb8s,2362
 tests/test_workflow.py,sha256=TmNBxBqSW5owk_Nz9LLtHvqryVNsFPkf-M1G_uFSsAM,3739
 vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
-vectara_agentic/_callback.py,sha256=DMExGJPiZPowB0gL7Re_3406BHg75go1cgzetfGb-KQ,13074
+vectara_agentic/_callback.py,sha256=c3848EMSpaQWXtuwdqRGbhgbZhiDwgGnemJkgm9yWAc,13238
 vectara_agentic/_observability.py,sha256=iZlByeQTyx6g3Y8aBYcdGcxdRkoYrfxHdcrTEKO26UE,4485
-vectara_agentic/_prompts.py,sha256=NbKloHQYc25IvtpxmPdRKHXIM-p-lAK-jyk41iafL60,10050
-vectara_agentic/_version.py,sha256=0nu9HU5L2IF3IL6m4qgh01FIE3SlzPwiUtSQI5-j0YI,66
-vectara_agentic/agent.py,sha256=M4hiHfrVBYIdknI5JMHezabF1QcM1jfHSCx2VXoVTQ4,55912
+vectara_agentic/_prompts.py,sha256=7PY1XBqFM5JGXSw5JzhE2QJylLawIjFv3xAEJ2AA0LQ,10550
+vectara_agentic/_version.py,sha256=_2691WFCS6Oetu4wBzc3283NHXo4gUI7OxlOWeNJwjI,65
+vectara_agentic/agent.py,sha256=S1Rek9Dp9HabDQPqdQlkIMUR701-XTonyoXeCRE9WtA,58215
 vectara_agentic/agent_config.py,sha256=E-rtYMcpoGxnEAyy8231bizo2n0uGQ2qWxuSgTEfwdQ,4327
 vectara_agentic/agent_endpoint.py,sha256=PzIN7HhEHv8Mq_Zo5cZ2xYrgdv2AN6kx6dc_2AJq28I,7497
 vectara_agentic/db_tools.py,sha256=GUsQTZfRbT9F5K_e5HNaKXUkU6x8RErUyjDVKlZi1IA,11196
-vectara_agentic/llm_utils.py,sha256=oYm2S_xBCacN6GmFr_ASMIKEtRy2z2EQ_qDBfgSpiWE,7247
+vectara_agentic/hhem.py,sha256=j4euBX24PSCQ8P_MhhsKKnm1kv6nHKAbduHsTwtQuR0,2774
+vectara_agentic/llm_utils.py,sha256=g-8Ja4g8X67u02pi7mQrb3O1nRre9lgeC6gJqngl5ow,7668
 vectara_agentic/sub_query_workflow.py,sha256=JYwN0wK4QzHjTaFDsSCAQvMx9GD4g6CnqxZCnzi6xb4,13086
-vectara_agentic/tool_utils.py,sha256=FkwKY2IsMHXIb-uD-wef8vVB_eZKkReeb74CcXGo1cQ,19219
-vectara_agentic/tools.py,sha256=SMBQeNZxklEfcnFbrTxOxlC173gdgDAPxJ7BGf9K-PQ,34298
+vectara_agentic/tool_utils.py,sha256=9xoqVPB97CIDXOxuFIw4yZ2RlXvdayCEGPUaUPC2Tbc,24168
+vectara_agentic/tools.py,sha256=bj8Zn3Lv63vWxu7N6_kkvOk9Vr2ZtuiiBetXUCzsK0w,34860
 vectara_agentic/tools_catalog.py,sha256=cAN_kDOWZUoW4GNFwY5GdS6ImMUQNnF2sggx9OGK9Cg,4906
-vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
+vectara_agentic/types.py,sha256=3mrtshHiy-d5JHVxl-4tJk5DRspvYKwAYiI5LvKO1Bw,2226
 vectara_agentic/utils.py,sha256=R9HitEG5K3Q_p2M_teosT181OUxkhs1-hnj98qDYGbE,2545
-vectara_agentic-0.2.24.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.24.dist-info/METADATA,sha256=l8iHPGRusQqBr0skx0j5DQ364CukPSdefsfZdVIqpcU,31127
-vectara_agentic-0.2.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vectara_agentic-0.2.24.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.24.dist-info/RECORD,,
+vectara_agentic-0.3.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.3.1.dist-info/METADATA,sha256=5QXewroE8dsANYXCoYr-MqAm0wlNhe205tVzWaCZnEw,32079
+vectara_agentic-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vectara_agentic-0.3.1.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.3.1.dist-info/RECORD,,