vectara-agentic 0.4.5__py3-none-any.whl → 0.4.7__py3-none-any.whl

tests/test_tools.py

@@ -15,6 +15,8 @@ from vectara_agentic.tools import (
     VectaraToolFactory,
     ToolsFactory,
     ToolType,
+    normalize_url,
+    citation_appears_in_text,
 )
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
@@ -367,6 +369,165 @@ class TestToolsPackage(unittest.TestCase):
         self.assertIn("Returns:", doc)
         self.assertIn("dict[str, Any]: A dictionary containing the result data.", doc)
 
+    def test_normalize_url(self):
+        """Test URL normalization function"""
+        # Test space encoding normalization
+        self.assertEqual(
+            normalize_url("http://example.com/file with spaces.pdf"),
+            "http://example.com/file%20with%20spaces.pdf",
+        )
+
+        # Test that already encoded URLs remain normalized
+        self.assertEqual(
+            normalize_url("http://example.com/file%20with%20spaces.pdf"),
+            "http://example.com/file%20with%20spaces.pdf",
+        )
+
+        # Test special characters
+        self.assertEqual(
+            normalize_url("http://example.com/path?query=hello world&foo=bar"),
+            "http://example.com/path?query=hello%20world&foo=bar",
+        )
+
+        # Test empty/None input
+        self.assertEqual(normalize_url(""), "")
+        self.assertEqual(normalize_url(None), None)
+
+        # Test complex URL with multiple encodable characters
+        result = normalize_url("http://example.com/docs/My Document [v2].pdf#section 1")
+        expected = "http://example.com/docs/My%20Document%20[v2].pdf#section%201"
+        self.assertEqual(result, expected)
+
+    def test_citation_appears_in_text_exact_match(self):
+        """Test citation matching with exact format"""
+        response_text = "Here's the info [Document Title](http://example.com/doc.pdf) for reference."
+
+        # Should match exact citation
+        self.assertTrue(
+            citation_appears_in_text(
+                "Document Title", "http://example.com/doc.pdf", response_text
+            )
+        )
+
+        # Should not match different text with different URL
+        self.assertFalse(
+            citation_appears_in_text(
+                "Wrong Title", "http://different.com/other.pdf", response_text
+            )
+        )
+
+    def test_citation_appears_in_text_url_encoding(self):
+        """Test citation matching with URL encoding differences"""
+        # Response text with percent-encoded URL
+        response_text_encoded = (
+            "See [My Doc](http://example.com/my%20document.pdf) for details."
+        )
+
+        # Should match when citation URL has spaces
+        self.assertTrue(
+            citation_appears_in_text(
+                "My Doc", "http://example.com/my document.pdf", response_text_encoded
+            )
+        )
+
+        # Response text with spaces in URL
+        response_text_spaces = (
+            "See [My Doc](http://example.com/my document.pdf) for details."
+        )
+
+        # Should match when citation URL is encoded
+        self.assertTrue(
+            citation_appears_in_text(
+                "My Doc", "http://example.com/my%20document.pdf", response_text_spaces
+            )
+        )
+
+    def test_citation_appears_in_text_url_presence(self):
+        """Test fallback URL presence matching"""
+        # Response text that contains URL but not in exact citation format
+        response_text = (
+            "The document at http://example.com/report.pdf contains the analysis."
+        )
+
+        # Should match based on URL presence
+        self.assertTrue(
+            citation_appears_in_text(
+                "Report", "http://example.com/report.pdf", response_text
+            )
+        )
+
+        # Should work with encoded URL in response
+        response_encoded = (
+            "The document at http://example.com/my%20report.pdf contains data."
+        )
+        self.assertTrue(
+            citation_appears_in_text(
+                "Report", "http://example.com/my report.pdf", response_encoded
+            )
+        )
+
+    def test_citation_appears_in_text_edge_cases(self):
+        """Test edge cases and error conditions"""
+        response_text = "Some text with [citations](http://example.com/doc.pdf) here."
+
+        # Empty inputs should return False
+        self.assertFalse(
+            citation_appears_in_text("", "http://example.com/doc.pdf", response_text)
+        )
+        self.assertFalse(citation_appears_in_text("Title", "", response_text))
+        self.assertFalse(
+            citation_appears_in_text("Title", "http://example.com/doc.pdf", "")
+        )
+        self.assertFalse(
+            citation_appears_in_text(None, "http://example.com/doc.pdf", response_text)
+        )
+
+        # Both None should return False
+        self.assertFalse(citation_appears_in_text(None, None, response_text))
+
+        # Very short filename should not trigger filename matching
+        self.assertFalse(
+            citation_appears_in_text(
+                "Title", "http://example.com/x.y", "Different content"
+            )
+        )
+
+    def test_citation_appears_in_text_complex_encoding(self):
+        """Test complex URL encoding scenarios"""
+        # Test case with multiple special characters
+        response_text = "Document: [Legal Doc](http://example.com/docs/Contract%20%5B2024%5D%20%26%20Agreement.pdf)"
+
+        # Should match with unencoded URL
+        self.assertTrue(
+            citation_appears_in_text(
+                "Legal Doc",
+                "http://example.com/docs/Contract [2024] & Agreement.pdf",
+                response_text,
+            )
+        )
+
+    def test_citation_appears_in_text_url_only(self):
+        """Test citation matching when only URL is available (no text)"""
+        # Test the [(url)] format when only URL is available
+        response_text = "Reference: [(http://example.com/report.pdf)] shows data."
+
+        # Should match with URL-only citation format
+        self.assertTrue(
+            citation_appears_in_text(
+                None, "http://example.com/report.pdf", response_text
+            )
+        )
+
+        # Should also work with URL encoding differences
+        response_encoded = (
+            "Reference: [(http://example.com/my%20report.pdf)] shows data."
+        )
+        self.assertTrue(
+            citation_appears_in_text(
+                None, "http://example.com/my report.pdf", response_encoded
+            )
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.4.5"
+__version__ = "0.4.7"

vectara_agentic/agent_core/prompts.py

@@ -23,7 +23,7 @@ GENERAL_INSTRUCTIONS = """
   In rephrasing, aim for alternative queries that may work better for searching for the information.
   For example, you can rephrase "CEO" with "Chief Executive Officer".
   2) Break the question into sub-questions and call this tool or another tool for each sub-question, then combine the answers to provide a complete response.
-  For example if asked "what is the population of France and Germany", you can call the tool twice, once for France and once for Germany.
+  For example if asked "what is the population of France and Germany", you can call the tool twice, once for France and once for Germany,
   and then combine the responses to provide the full answer.
   3) If a tool fails, try other tools that might be appropriate to gain the information you need.
 - If after retrying you can't get the information or answer the question, respond with "I don't know".
@@ -31,22 +31,22 @@ GENERAL_INSTRUCTIONS = """
   Be consistent with the format of numbers and dates across multi turn conversations.
 - Handling citations - IMPORTANT:
   1) Always embed citations inline with the text of your response, using valid URLs provided by tools.
-     Never omit a legitimate citations.
-     Avoid creating a bibliography or a list of sources at the end of your response, and referring the reader to that list.
+     Never omit a legitimate citation.
+     Never repeat the same citation multiple times in a response.
+  2) Avoid creating a bibliography or a list of sources at the end of your response, and referring the reader to that list.
      Instead, embed citations directly in the text where the information is presented.
      For example, "According to the [Nvidia 10-K report](https://www.nvidia.com/doc.pdf#page=8), revenue in 2021 was $10B."
-  2) When including URLs in the citation, only use well-formed, non-empty URLs (beginning with “http://” or “https://”) and ignore any malformed or placeholder links.
-  3) Use descriptive link text for citations whenever possible, falling back to numeric labels only when necessary.
+  3) When including URLs in the citation, only use well-formed, non-empty URLs (beginning with “http://” or “https://”) and ignore any malformed or placeholder links.
+  4) Use descriptive link text for citations whenever possible, falling back to numeric labels only when necessary.
      Preferred: "According to the [Nvidia 10-K report](https://www.nvidia.com/doc.pdf#page=8), revenue in 2021 was $10B."
      Fallback: "According to the Nvidia 10-K report, revenue in 2021 was $10B [1](https://www.nvidia.com/doc.pdf#page=8)."
-  4) If a URL is for a PDF file, and the tool also provided a page number, append "#page=X" to the URL.
+  5) If a URL is for a PDF file, and the tool also provided a page number, append "#page=X" to the URL.
      For example, if the URL is "https://www.xxx.com/doc.pdf" and "page='5'", then the URL used in the citation would be "https://www.xxx.com/doc.pdf#page=5".
      Always include the page number in the URL, whether you use anchor text or a numeric label.
-  5) When citing images, figures, or tables, link directly to the file (or PDF page) just as you would for text.
-  6) Give each discrete fact its own citation (or citations), even if multiple facts come from the same document.
-     Avoid lumping multiple pages into one citation.
-  7) Ensure a space or punctuation precedes and follows every citation.
-     Here's an example where there is no proper spacing, and the citation is shown right after "10-K": "As shown in the [Nvidia 10-K](https://www.nvidia.com), the revenue in 2021 was $10B".
+  6) When citing images, figures, or tables, link directly to the file (or PDF page) just as you would for text.
+  7) Give each discrete fact its own citation (or citations), even if multiple facts come from the same document.
+  8) Ensure a space or punctuation precedes and follows every citation.
+     Here's an example where there is no proper spacing, and the citation is shown right after "10-K": "As shown in the[Nvidia 10-K](https://www.nvidia.com), the revenue in 2021 was $10B".
      Instead use spacing properly: "As shown in the [Nvidia 10-K](https://www.nvidia.com), the revenue in 2021 was $10B".
 - If a tool returns a "Malfunction" error - notify the user that you cannot respond due a tool not operating properly (and the tool name).
 - Your response should never be the input to a tool, only the output.

vectara_agentic/agent_core/streaming.py

@@ -302,6 +302,7 @@ class FunctionCallingStreamHandler:
                     hasattr(ev, "tool_calls")
                     and not ev.tool_calls
                     and hasattr(ev, "delta")
+                    and transitioned_to_prose
                 ):
                     yield ev.delta
 
@@ -311,16 +312,16 @@ class FunctionCallingStreamHandler:
         except Exception as e:
             error_str = str(e).lower()
             if "rate limit" in error_str or "429" in error_str:
-                logging.error(f"🔍 [RATE_LIMIT_ERROR] Rate limit exceeded: {e}")
+                logging.error(f"[RATE_LIMIT_ERROR] Rate limit exceeded: {e}")
                 self.final_response_container["resp"] = AgentResponse(
                     response="Rate limit exceeded. Please try again later.",
                     source_nodes=[],
                     metadata={"error_type": "rate_limit", "original_error": str(e)},
                 )
             else:
-                logging.error(f"🔍 [STREAM_ERROR] Error processing stream events: {e}")
+                logging.error(f"[STREAM_ERROR] Error processing stream events: {e}")
                 logging.error(
-                    f"🔍 [STREAM_ERROR] Full traceback: {traceback.format_exc()}"
+                    f"[STREAM_ERROR] Full traceback: {traceback.format_exc()}"
                 )
                 self.final_response_container["resp"] = AgentResponse(
                     response="Response completion Error",
@@ -590,10 +591,10 @@ class ReActStreamHandler:
             self.final_response_container["resp"] = await self.handler
         except Exception as e:
             logging.error(
-                f"🔍 [REACT_STREAM_ERROR] Error processing ReAct stream events: {e}"
+                f"[REACT_STREAM_ERROR] Error processing ReAct stream events: {e}"
             )
             logging.error(
-                f"🔍 [REACT_STREAM_ERROR] Full traceback: {traceback.format_exc()}"
+                f"[REACT_STREAM_ERROR] Full traceback: {traceback.format_exc()}"
             )
             self.final_response_container["resp"] = AgentResponse(
                 response="ReAct Response completion Error", source_nodes=[], metadata={}

vectara_agentic/agent_core/utils/tools.py

@@ -9,9 +9,11 @@ import inspect
 from typing import Any, List
 from inspect import Signature, Parameter, ismethod
 from collections import Counter
+import logging
 
 from pydantic import Field, create_model
 from llama_index.core.tools import FunctionTool
+
 from ...llm_utils import get_llm
 from ...types import LLMRole
 
@@ -37,17 +39,23 @@ def sanitize_tools_for_gemini(tools: List[FunctionTool]) -> List[FunctionTool]:
         for func in (tool.fn, tool.async_fn):
             if not func:
                 continue
-            orig_sig = inspect.signature(func)
-            new_params = [
-                p.replace(default=Parameter.empty) for p in orig_sig.parameters.values()
-            ]
-            new_sig = Signature(
-                new_params, return_annotation=orig_sig.return_annotation
-            )
-            if ismethod(func):
-                func.__func__.__signature__ = new_sig
-            else:
-                func.__signature__ = new_sig
+            try:
+                orig_sig = inspect.signature(func)
+                new_params = [
+                    p.replace(default=Parameter.empty) for p in orig_sig.parameters.values()
+                ]
+                new_sig = Signature(
+                    new_params, return_annotation=orig_sig.return_annotation
+                )
+                if ismethod(func):
+                    func.__func__.__signature__ = new_sig
+                else:
+                    func.__signature__ = new_sig
+            except Exception as e:
+                logging.warning(
+                    f"Could not modify signature for tool '{tool.metadata.name}': {e}. "
+                    "Proceeding with Pydantic schema modification."
+                )
 
         # 2) Rebuild the Pydantic schema so that *every* field is required
         schema_cls = getattr(tool.metadata, "fn_schema", None)

vectara_agentic/tools.py

@@ -6,7 +6,9 @@ import inspect
 import importlib
 import os
 import asyncio
+import urllib.parse
 from typing import Callable, List, Dict, Any, Optional, Union
+import logging
 
 from retrying import retry
 from pydantic import BaseModel, Field
@@ -65,6 +67,105 @@ LI_packages = {
 }
 
 
+def normalize_url(url):
+    """
+    Normalize URL for consistent comparison by handling percent-encoding.
+
+    Args:
+        url (str): The URL to normalize
+
+    Returns:
+        str: Normalized URL with consistent percent-encoding
+    """
+    if not url:
+        return url
+
+    try:
+        # Decode percent-encoded characters
+        decoded = urllib.parse.unquote(url)
+        # Re-encode consistently using standard safe characters
+        normalized = urllib.parse.quote(decoded, safe=':/?#[]@!$&\'()*+,;=')
+        return normalized
+    except Exception as e:
+        logging.warning(f"Error normalizing URL '{url}': {e}")
+        return url
+
+
+def citation_appears_in_text(citation_text, citation_url, response_text):
+    """
+    Check if citation appears in response text using multiple matching strategies.
+    Handles citation formatting internally based on available text and URL.
+
+    Args:
+        citation_text (str): The text part of the citation (can be None)
+        citation_url (str): The URL part of the citation (can be None)
+        response_text (str): The response text to search in
+
+    Returns:
+        bool: True if citation appears in response text
+    """
+    if not response_text:
+        return False
+
+    # If no citation info available, return False
+    # Empty strings should be treated as None
+    if not citation_text and not citation_url:
+        return False
+
+    # Generate possible citation formats based on available data
+    citation_formats = []
+
+    # Normalize empty strings to None for cleaner logic
+    if citation_text == "":
+        citation_text = None
+    if citation_url == "":
+        citation_url = None
+
+    if citation_text and citation_url:
+        citation_formats.append(f"[{citation_text}]({citation_url})")
+        # Also try with normalized URL
+        normalized_url = normalize_url(citation_url)
+        if normalized_url != citation_url:
+            citation_formats.append(f"[{citation_text}]({normalized_url})")
+        # Also try with decoded URL (for cases where input is encoded but response has spaces)
+        decoded_url = urllib.parse.unquote(citation_url)
+        if decoded_url != citation_url:
+            citation_formats.append(f"[{citation_text}]({decoded_url})")
+        # Also try with aggressive encoding (encode more characters)
+        aggressive_encoded = urllib.parse.quote(decoded_url, safe=':/?#')
+        if aggressive_encoded not in (citation_url, normalized_url):
+            citation_formats.append(f"[{citation_text}]({aggressive_encoded})")
+    elif citation_url:
+        # Handle case where only URL is available (original logic: "[({url})]")
+        citation_formats.append(f"[({citation_url})]")
+        normalized_url = normalize_url(citation_url)
+        if normalized_url != citation_url:
+            citation_formats.append(f"[({normalized_url})]")
+        decoded_url = urllib.parse.unquote(citation_url)
+        if decoded_url != citation_url:
+            citation_formats.append(f"[({decoded_url})]")
+
+    # Strategy 1: Exact citation format matches
+    for citation_format in citation_formats:
+        if citation_format in response_text:
+            return True
+
+    # Strategy 2: URL appears anywhere in response (more lenient)
+    # Only apply this strategy if we have both citation_text and citation_url
+    # URL-only matching happens in Strategy 1 through citation formats
+    if citation_text and citation_url:
+        normalized_url = normalize_url(citation_url)
+        # Try both encoded and decoded versions
+        decoded_url = urllib.parse.unquote(citation_url)
+
+        if (citation_url in response_text or
+            normalized_url in response_text or
+            decoded_url in response_text):
+            return True
+
+    return False
+
+
 @retry(stop_max_attempt_number=3, wait_exponential_multiplier=1000, wait_exponential_max=10000)
 def _query_with_retry(vectara_query_engine, query):
     """Execute Vectara query with automatic retry on timeout/failure."""
@@ -595,11 +696,16 @@ class VectaraToolFactory:
                         part_data = {k: v for k, v in node_metadata.items() if k != 'document'}
                         template_data['part'] = to_obj(part_data)
 
-                        formatted_citation_text = computed_citations_text_pattern.format(**template_data)
-                        formatted_citation_url = computed_citations_url_pattern.format(**template_data)
-                        expected_citation = f"[{formatted_citation_text}]({formatted_citation_url})"
+                        try:
+                            formatted_citation_text = computed_citations_text_pattern.format(**template_data)
+                        except Exception:
+                            formatted_citation_text = None
+                        try:
+                            formatted_citation_url = computed_citations_url_pattern.format(**template_data)
+                        except Exception:
+                            formatted_citation_url = None
 
-                        if expected_citation in response_text:
+                        if citation_appears_in_text(formatted_citation_text, formatted_citation_url, response_text):
                             citation_metadata.append({
                                 'doc_id': node_id,
                                 'text': node_text,
@@ -673,7 +779,8 @@ class ToolsFactory:
             VectaraTool: A VectaraTool object.
         """
         return VectaraTool.from_defaults(
-            tool_type=tool_type, fn=function, vhc_eligible=vhc_eligible
+            tool_type=tool_type, fn=function, vhc_eligible=vhc_eligible,
+            description=function.__doc__,
         )
 
     def get_llama_index_tools(

{vectara_agentic-0.4.5.dist-info → vectara_agentic-0.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.4.5
+Version: 0.4.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
@@ -16,20 +16,20 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: llama-index==0.13.3
-Requires-Dist: llama-index-core==0.13.3
+Requires-Dist: llama-index==0.13.6
+Requires-Dist: llama-index-core==0.13.6
 Requires-Dist: llama-index-workflows==1.3.0
 Requires-Dist: llama-index-cli==0.5.0
 Requires-Dist: llama-index-indices-managed-vectara==0.5.0
 Requires-Dist: llama-index-llms-openai==0.5.4
 Requires-Dist: llama-index-llms-openai-like==0.5.0
-Requires-Dist: llama-index-llms-anthropic==0.8.5
+Requires-Dist: llama-index-llms-anthropic==0.8.6
 Requires-Dist: llama-index-llms-together==0.4.0
 Requires-Dist: llama-index-llms-groq==0.4.0
 Requires-Dist: llama-index-llms-cohere==0.6.0
 Requires-Dist: llama-index-llms-google-genai==0.3.0
 Requires-Dist: google_genai>=1.31.0
-Requires-Dist: llama-index-llms-bedrock-converse==0.8.2
+Requires-Dist: llama-index-llms-bedrock-converse==0.9.0
 Requires-Dist: llama-index-tools-yahoo-finance==0.4.0
 Requires-Dist: llama-index-tools-arxiv==0.4.0
 Requires-Dist: llama-index-tools-database==0.4.0

{vectara_agentic-0.4.5.dist-info → vectara_agentic-0.4.7.dist-info}/RECORD

@@ -23,14 +23,14 @@ tests/test_serialization.py,sha256=DJZ2E_K54t8INwZR0Q8gS1wi-MGbLIheOBcbRmZNcro,5
 tests/test_session_memory.py,sha256=hnADl59agjpXySY-CBjw6sDPn3s6JketIK6XbLZsLzU,9691
 tests/test_streaming.py,sha256=r-kj6DOB7sn2mkEv_8msGgIYeKXEtWgrDF2qTtCqnZY,1828
 tests/test_together.py,sha256=zR06GoFU0549VYKZRZ5z8bbpvQ6l_vLA0bYLp5SokuU,4770
-tests/test_tools.py,sha256=vvi3FC4SDOwpyKJUFOWCWJ5i3Y474FrKFHnZpo4aFQg,13643
+tests/test_tools.py,sha256=W_V5NHjRfEX_Lrh5jNhhZbeKsRdFVUJNTOKfX1hkJGg,19638
 tests/test_vectara_llms.py,sha256=WoswpfPGhQlBXyOijn5EBX0F2NL1Oq3FDB4wxu7mwXs,2485
 tests/test_vhc.py,sha256=jVojp8ZUDF60yJaYp5pBRdAdNYK1hhhPz_RTmlTEm4g,1980
 tests/test_workflow.py,sha256=43YUF-0YDbiiJrTSYjnyqrC4gvHYuHQp7uuzV2jMdTE,3553
 vectara_agentic/__init__.py,sha256=CfS3QR4drKygcTcyH5zUUDuXXQ3WZtTCytz8W4-loeE,1077
 vectara_agentic/_callback.py,sha256=hYbHU_3sMF4-h0YMierZ9EEWspakNixk7wXAAWztlmU,15364
 vectara_agentic/_observability.py,sha256=rApfdndB2R021iM0xG4MumTSDX1Ba6qbNM0N_AOTbR0,4884
-vectara_agentic/_version.py,sha256=yIMD44QzaC80CY-19KOCtwI1vMinyd_IEp-_hvxhBlQ,65
+vectara_agentic/_version.py,sha256=LVDemBeUlAXxk_tSkMeZxasQy5XKZ9fTZCIyTuUQTGg,65
 vectara_agentic/agent.py,sha256=5eC4BkMPWep8c_LIHSB2N1CvsFLdX6qPAhIpgLR08Gc,49125
 vectara_agentic/agent_config.py,sha256=njqEX2qHJjAp2KpNuJglgZhyWXPK74wjIjBPACD6w7w,4074
 vectara_agentic/agent_endpoint.py,sha256=E_AF-YwxaKqd1-p43X62e1e4ugwOWKIyNq4RWOfsO7A,7402
@@ -38,22 +38,22 @@ vectara_agentic/db_tools.py,sha256=nVZkpGdG63ooGngjX9g7YWyBZRtYMDpvzNasbO696nM,1
 vectara_agentic/llm_utils.py,sha256=CqrBOMf9sL-CD0xD-yiEYNyduZV4GBho4e518z_pt5s,9422
 vectara_agentic/sub_query_workflow.py,sha256=1y0fBoUem4i-R34QYlSzcMwM8YhmYgj6S_bWynUtL6w,13001
 vectara_agentic/tool_utils.py,sha256=whnQlk9coeIt01sqUnKnzUorefgn96yWqhtRfHxNL84,25921
-vectara_agentic/tools.py,sha256=yF1y7jPR5jLQXvn-orjCYb0vy_o8WStU36WA8A3guEM,37554
+vectara_agentic/tools.py,sha256=nqfSkiLbuzjAud2pWgVMSvRj_N6M25Lii5quJWYKbeU,41614
 vectara_agentic/tools_catalog.py,sha256=p6eRram-diJyMz5dZI703auSAm97FfW5wLAMyz_2sB0,4634
 vectara_agentic/types.py,sha256=qKkK8vRNiLvEcMInMyOClK2bD7iFlrWGTkl3fGC6Xic,6117
 vectara_agentic/utils.py,sha256=R9HitEG5K3Q_p2M_teosT181OUxkhs1-hnj98qDYGbE,2545
 vectara_agentic/agent_core/__init__.py,sha256=R3KGbSOiY21FOjbeQ_GyIi6uR9Rz7PTfudO9RjSuEZQ,722
 vectara_agentic/agent_core/factory.py,sha256=Nmmhl98r2Op4qJwq9cgfy7DfrWI62JUfxFXHoBxKHBo,14158
-vectara_agentic/agent_core/prompts.py,sha256=al7SF5pNzOG-KK0lCtTS-HCwVStB6yvE34dgHWJQ_bA,9989
+vectara_agentic/agent_core/prompts.py,sha256=bpUJ2JvQ9IYZZkNyTBzoFKcOVasixsZc0nLu9vNDLBY,10000
 vectara_agentic/agent_core/serialization.py,sha256=Npfcgm9j8B0ck74uIUgqTGljt8HTpcMCdnWV6CKYBZE,11878
-vectara_agentic/agent_core/streaming.py,sha256=OmjTNEJ25SR788ltyvekVpP83hnv6Tw-MixCwOUK9Kc,26452
+vectara_agentic/agent_core/streaming.py,sha256=mTHjCWBMMCeEDre_FqhXM27251M8fxSmDwcrOt-wfuw,26473
 vectara_agentic/agent_core/utils/__init__.py,sha256=y5Xf0IH-5TRxMBRA9IyhmWnGZOVIyqV45P6lX4c2Qsc,762
 vectara_agentic/agent_core/utils/hallucination.py,sha256=XmV7tW-MBN9BrzM79zu0T7zaWil7fIkNQjLfDZE43v4,5312
 vectara_agentic/agent_core/utils/logging.py,sha256=-Ll8iUelml92WuhNWScuY6H-RheyZOTBHNxXQ1UGy0M,1701
 vectara_agentic/agent_core/utils/schemas.py,sha256=4sEyQ-_z-eZJzgxCJf62AuBgV7RN1Azc9mLPPlj6IWg,2769
-vectara_agentic/agent_core/utils/tools.py,sha256=k9Gm-UUQ3ZeGxrkjyrjmjcGxOkvnpylcm_Krnr-0fsY,4748
-vectara_agentic-0.4.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.4.5.dist-info/METADATA,sha256=dd9rDNw5x0hU2npZEHg9XSsJQebDKHVHHvSAf1zyxO8,38906
-vectara_agentic-0.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vectara_agentic-0.4.5.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.4.5.dist-info/RECORD,,
+vectara_agentic/agent_core/utils/tools.py,sha256=JQmiWldJd2_9SXE9cCEF9u4ESLJr15-JemORAAZbgnk,5068
+vectara_agentic-0.4.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.4.7.dist-info/METADATA,sha256=nsbgh52lR8Dn01zeDX5mgWrFvEC04DMROyYw_QZYZuA,38906
+vectara_agentic-0.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vectara_agentic-0.4.7.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.4.7.dist-info/RECORD,,