vectara-agentic 0.2.14__tar.gz → 0.2.15__tar.gz

{vectara_agentic-0.2.14/vectara_agentic.egg-info → vectara_agentic-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.14
+Version: 0.2.15
 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

vectara_agentic-0.2.15/tests/test_return_direct.py

@@ -0,0 +1,49 @@
+import unittest
+
+from vectara_agentic.agent import Agent
+from vectara_agentic.tools import VectaraToolFactory
+
+vectara_corpus_key = "vectara-docs_1"
+vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
+
+
+class TestAgentPackage(unittest.TestCase):
+
+    def test_return_direct1(self):
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+
+        query_tool = vec_factory.create_rag_tool(
+            tool_name="rag_tool",
+            tool_description="""
+            A dummy tool for testing return_direct.
+            """,
+            return_direct=True,
+        )
+
+        agent = Agent(
+            tools=[query_tool],
+            topic="Sample topic",
+            custom_instructions="You are a helpful assistant.",
+        )
+        res = agent.chat("What is Vectara?")
+        self.assertIn("Response:", str(res))
+        self.assertIn("fcs_score", str(res))
+        self.assertIn("References:", str(res))
+
+    def test_from_corpus(self):
+        agent = Agent.from_corpus(
+            tool_name="rag_tool",
+            vectara_corpus_key=vectara_corpus_key,
+            vectara_api_key=vectara_api_key,
+            data_description="stuff about Vectara",
+            assistant_specialty="question answering",
+            return_direct=True,
+        )
+        res = agent.chat("What is Vectara?")
+        self.assertIn("Response:", str(res))
+        self.assertIn("fcs_score", str(res))
+        self.assertIn("References:", str(res))
+
+
+if __name__ == "__main__":
+    unittest.main()

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/tests/test_tools.py

@@ -196,7 +196,7 @@ class TestToolsPackage(unittest.TestCase):
             custom_instructions="Call the tool with 15 arguments for OPENAI",
             agent_config=config,
         )
-        res = agent.chat("What is the stock price?")
+        res = agent.chat("What is the stock price for Yahoo on 12/31/22?")
         self.assertIn("maximum length of 1024 characters", str(res))
 
         # Same test but with GROQ

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/tests/test_vectara_llms.py

@@ -15,7 +15,10 @@ vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
 class TestLLMPackage(unittest.TestCase):
 
     def test_vectara_openai(self):
-        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+        vec_factory = VectaraToolFactory(
+            vectara_corpus_key=vectara_corpus_key,
+            vectara_api_key=vectara_api_key
+        )
 
         self.assertEqual(vectara_corpus_key, vec_factory.vectara_corpus_key)
         self.assertEqual(vectara_api_key, vec_factory.vectara_api_key)

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/vectara_agentic/_observability.py

@@ -12,28 +12,50 @@ def setup_observer(config: AgentConfig, verbose: bool) -> bool:
     '''
     Setup the observer.
     '''
-    import phoenix as px
-    from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
-    from phoenix.otel import register
-    if config.observer == ObserverType.ARIZE_PHOENIX:
-        phoenix_endpoint = os.getenv("PHOENIX_ENDPOINT", None)
-        if not phoenix_endpoint:
-            px.launch_app()
-            tracer_provider = register(endpoint='http://localhost:6006/v1/traces', project_name="vectara-agentic")
-        elif 'app.phoenix.arize.com' in phoenix_endpoint:   # hosted on Arize
-            phoenix_api_key = os.getenv("PHOENIX_API_KEY", None)
-            if not phoenix_api_key:
-                raise ValueError("Arize Phoenix API key not set. Please set PHOENIX_API_KEY environment variable.")
-            os.environ["PHOENIX_CLIENT_HEADERS"] = f"api_key={phoenix_api_key}"
-            os.environ["PHOENIX_COLLECTOR_ENDPOINT"] = "https://app.phoenix.arize.com"
-            tracer_provider = register(endpoint=phoenix_endpoint, project_name="vectara-agentic")
-        else:       # Self hosted Phoenix
-            tracer_provider = register(endpoint=phoenix_endpoint, project_name="vectara-agentic")
-        LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)
-        return True
+    if config.observer != ObserverType.ARIZE_PHOENIX:
+        if verbose:
+            print("No Phoenix observer set.")
+        return False
+
+    try:
+        import phoenix as px
+        from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
+        from phoenix.otel import register
+    except ImportError:
+        print(
+            (
+                "Phoenix libraries not found. Please install with"
+                "'pip install arize-phoenix openinference-instrumentation-llama-index'"
+            )
+        )
+        return False
+
+    phoenix_endpoint = os.getenv("PHOENIX_ENDPOINT", None)
+    if not phoenix_endpoint:
+        print("Phoenix endpoint not set. Attempting to launch local Phoenix UI...")
+        px.launch_app()
+        print("Local Phoenix UI launched. You can view traces at the UI address (usually http://localhost:6006).")
+
+    if phoenix_endpoint and 'app.phoenix.arize.com' in phoenix_endpoint:
+        phoenix_api_key = os.getenv("PHOENIX_API_KEY")
+        if not phoenix_api_key:
+            raise ValueError(
+                "Arize Phoenix API key not set. Please set PHOENIX_API_KEY."
+            )
+        os.environ["PHOENIX_CLIENT_HEADERS"] = f"api_key={phoenix_api_key}"
+        os.environ["PHOENIX_COLLECTOR_ENDPOINT"] = "https://app.phoenix.arize.com"
+
+    reg_kwargs = {
+        "endpoint": phoenix_endpoint or 'http://localhost:6006/v1/traces',
+        "project_name": "vectara-agentic",
+        "batch": True,
+        "set_global_tracer_provider": False,
+    }
+    tracer_provider = register(**reg_kwargs)
+    LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)
     if verbose:
-        print("No observer set.")
-    return False
+        print(f"Phoenix observer configured for project 'vectara-agentic' at endpoint: {reg_kwargs['endpoint']}")
+    return True
 
 
 def _extract_fcs_value(output: Union[str, dict]) -> Optional[float]:

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/vectara_agentic/_prompts.py

@@ -5,7 +5,7 @@ This file contains the prompt templates for the different types of agents.
 # General (shared) instructions
 GENERAL_INSTRUCTIONS = """
 - Use tools as your main source of information, do not respond without using a tool. Do not respond based on pre-trained knowledge.
-- Use the 'get_bad_topics' tool to determine the topics you are not allowed to discuss or respond to.
+- Use the 'get_bad_topics' (if it exists) tool to determine the topics you are not allowed to discuss or respond to.
 - Before responding to a user query that requires knowledge of the current date, call the 'get_current_date' tool to get the current date.
   Never rely on previous knowledge of the current date.
   Example queries that require the current date: "What is the revenue of Apple last october?" or "What was the stock price 5 days ago?".

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.14"
+__version__ = "0.2.15"

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/vectara_agentic/agent.py

@@ -248,19 +248,25 @@ class Agent:
 
         if validate_tools:
             prompt = f"""
-            Given the following instructions, and a list of tool names,
-            Please identify tools mentioned in the instructions that do not exist in the list.
-            Instructions:
+            You are provided these tools:
+            <tools>{','.join(tool_names)}</tools>
+            And these instructions:
+            <instructions>
             {self._custom_instructions}
-            Tool names: {', '.join(tool_names)}
-            Your response should include a comma separated list of tool names that do not exist in the list.
-            Your response should be an empty string if all tools mentioned in the instructions are in the list.
+            </instructions>
+            Your task is to identify invalid tools.
+            A tool is invalid if it is mentioned in the instructions but not in the tools list.
+            A tool's name must have at least two characters.
+            Your response should be a comma-separated list of the invalid tools.
+            If not invalid tools exist, respond with "<OKAY>".
             """
             llm = get_llm(LLMRole.MAIN, config=self.agent_config)
-            bad_tools = llm.complete(prompt).text.split(", ")
-            if bad_tools:
+            bad_tools_str = llm.complete(prompt).text
+            if bad_tools_str and bad_tools_str != "<OKAY>":
+                bad_tools = [tool.strip() for tool in bad_tools_str.split(",")]
+                numbered = ", ".join(f"({i}) {tool}" for i, tool in enumerate(bad_tools, 1))
                 raise ValueError(
-                    f"The Agent custom instructions mention these invalid tools: {', '.join(bad_tools)}"
+                    f"The Agent custom instructions mention these invalid tools: {numbered}"
                 )
 
         # Create token counters for the main and tool LLMs
@@ -689,6 +695,7 @@ class Agent:
         vectara_frequency_penalty: Optional[float] = None,
         vectara_presence_penalty: Optional[float] = None,
         vectara_save_history: bool = True,
+        return_direct: bool = False,
     ) -> "Agent":
         """
         Create an agent from a single Vectara corpus
@@ -738,6 +745,7 @@ class Agent:
             vectara_presence_penalty (float, optional): How much to penalize repeating tokens in the response,
                 higher values increasing the diversity of topics.
             vectara_save_history (bool, optional): Whether to save the query in history.
+            return_direct (bool, optional): Whether the agent should return the tool's response directly.
 
         Returns:
             Agent: An instance of the Agent class.
@@ -791,6 +799,7 @@ class Agent:
             save_history=vectara_save_history,
             include_citations=True,
             verbose=verbose,
+            return_direct=return_direct,
         )
 
         assistant_instructions = f"""

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/vectara_agentic/tool_utils.py

@@ -231,44 +231,119 @@ class VectaraTool(FunctionTool):
             return err_output
 
 
-def _create_tool_from_dynamic_function(
+class EmptyBaseModel(BaseModel):
+    """empty base model"""
+
+def _unwrap_default(default):
+    # PydanticUndefined means “no default — required”
+    return default if default is not PydanticUndefined else inspect.Parameter.empty
+
+def _schema_default(default):
+    # PydanticUndefined ⇒ Ellipsis (required)
+    return default if default is not PydanticUndefined else ...
+
+def _make_docstring(
+    function: Callable[..., ToolOutput],
+    tool_name: str,
+    tool_description: str,
+    fn_schema: Type[BaseModel],
+    all_params: List[inspect.Parameter],
+    compact_docstring: bool,
+) -> str:
+    params_str = ", ".join(
+        f"{p.name}: {p.annotation.__name__ if hasattr(p.annotation, '__name__') else p.annotation}"
+        for p in all_params
+    )
+    signature_line = f"{tool_name}({params_str}) -> dict[str, Any]"
+    if compact_docstring:
+        doc_lines = [tool_description.strip()]
+    else:
+        doc_lines = [signature_line, "", tool_description.strip()]
+    doc_lines += [
+        "",
+        "Args:",
+    ]
+
+    full_schema = fn_schema.model_json_schema()
+    props = full_schema.get("properties", {})
+    for prop_name, schema_prop in props.items():
+        desc = schema_prop.get("description", "")
+
+        # pick up any examples you declared on the Field or via schema_extra
+        examples = schema_prop.get("examples", [])
+        default = schema_prop.get("default", PydanticUndefined)
+
+        # format the type, default, description, examples
+        # find the matching inspect.Parameter so you get its annotation
+        param = next((p for p in all_params if p.name == prop_name), None)
+        if param and hasattr(param.annotation, "__name__"):
+            ty = param.annotation.__name__
+        else:
+            ty = schema_prop.get("type", "")
+
+        # inline default if present
+        default_txt = f", default={default!r}" if default is not PydanticUndefined else ""
+
+        # inline examples if any
+        if examples:
+            examples_txt = ", ".join(repr(e) for e in examples)
+            desc = f"{desc}  (e.g., {examples_txt})"
+
+        doc_lines.append(f"  - {prop_name} ({ty}{default_txt}): {desc}")
+
+    doc_lines.append("")
+    doc_lines.append("Returns:")
+    return_desc = getattr(
+        function, "__return_description__", "A dictionary containing the result data."
+    )
+    doc_lines.append(f"    dict[str, Any]: {return_desc}")
+
+    initial_docstring = "\n".join(doc_lines)
+    collapsed_spaces = re.sub(r' {2,}', ' ', initial_docstring)
+    final_docstring = re.sub(r'\n{2,}', '\n', collapsed_spaces).strip()
+    return final_docstring
+
+
+def create_tool_from_dynamic_function(
     function: Callable[..., ToolOutput],
     tool_name: str,
     tool_description: str,
     base_params_model: Type[BaseModel],
     tool_args_schema: Type[BaseModel],
     compact_docstring: bool = False,
+    return_direct: bool = False,
 ) -> VectaraTool:
-    base_params = []
-
+    """
+    Create a VectaraTool from a dynamic function.
+    Args:
+        function (Callable[..., ToolOutput]): The function to wrap as a tool.
+        tool_name (str): The name of the tool.
+        tool_description (str): The description of the tool.
+        base_params_model (Type[BaseModel]): The Pydantic model for the base parameters.
+        tool_args_schema (Type[BaseModel]): The Pydantic model for the tool arguments.
+        compact_docstring (bool): Whether to use a compact docstring format.
+    Returns:
+        VectaraTool: The created VectaraTool.
+    """
     if tool_args_schema is None:
-
-        class EmptyBaseModel(BaseModel):
-            """empty base model"""
-
         tool_args_schema = EmptyBaseModel
 
+    if not isinstance(tool_args_schema, type) or not issubclass(tool_args_schema, BaseModel):
+        raise TypeError("tool_args_schema must be a Pydantic BaseModel subclass")
+
     fields = {}
-    for param_name, model_field in base_params_model.model_fields.items():
-        field_type = base_params_model.__annotations__.get(
-            param_name, str
-        )
-        default_value = (
-            model_field.default
-            if model_field.default is not None
-            else inspect.Parameter.empty
-        )
+    base_params = []
+    for field_name, field_info in base_params_model.model_fields.items():
+        field_type = field_info.annotation
+        default_value = _unwrap_default(field_info.default)
         param = inspect.Parameter(
-            param_name,
+            field_name,
             inspect.Parameter.POSITIONAL_OR_KEYWORD,
             default=default_value,
             annotation=field_type,
         )
         base_params.append(param)
-        fields[param_name] = (
-            field_type,
-            model_field.default if model_field.default is not None else ...,
-        )
+        fields[field_name] = (field_type, _schema_default(field_info.default))
 
     # Add tool_args_schema fields to the fields dict if not already included.
     # Also add them to the function signature by creating new inspect.Parameter objects.
@@ -276,20 +351,16 @@ def _create_tool_from_dynamic_function(
         if field_name in fields:
             continue
 
-        default_value = field_info.default if field_info.default is not None else ...
-        field_type = tool_args_schema.__annotations__.get(field_name, None)
-        fields[field_name] = (field_type, default_value)
+        field_type = field_info.annotation
+        default_value = _unwrap_default(field_info.default)
         param = inspect.Parameter(
             field_name,
             inspect.Parameter.POSITIONAL_OR_KEYWORD,
-            default=(
-                default_value
-                if default_value is not ...
-                else inspect.Parameter.empty
-            ),
+            default=default_value,
             annotation=field_type,
         )
         base_params.append(param)
+        fields[field_name] = (field_type, _schema_default(field_info.default))
 
     # Create the dynamic schema with both base_params_model and tool_args_schema fields.
     fn_schema = create_model(f"{tool_name}_schema", **fields)
@@ -304,87 +375,39 @@ def _create_tool_from_dynamic_function(
     function.__annotations__["return"] = dict[str, Any]
     function.__name__ = re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
 
-    # Build a docstring using parameter descriptions from the BaseModels.
-    params_str = ", ".join(
-        f"{p.name}: {p.annotation.__name__ if hasattr(p.annotation, '__name__') else p.annotation}"
-        for p in all_params
+    function.__doc__ = _make_docstring(
+        function,
+        tool_name, tool_description, fn_schema,
+        all_params, compact_docstring
     )
-    signature_line = f"{tool_name}({params_str}) -> dict[str, Any]"
-    if compact_docstring:
-        doc_lines = [
-            tool_description.strip(),
-        ]
-    else:
-        doc_lines = [
-            signature_line,
-            "",
-            tool_description.strip(),
-        ]
-    doc_lines += [
-        "",
-        "Args:",
-    ]
-    for param in all_params:
-        description = ""
-        if param.name in base_params_model.model_fields:
-            description = base_params_model.model_fields[param.name].description
-        elif param.name in tool_args_schema.model_fields:
-            description = tool_args_schema.model_fields[param.name].description
-        if not description:
-            description = ""
-        type_name = (
-            param.annotation.__name__
-            if hasattr(param.annotation, "__name__")
-            else str(param.annotation)
-        )
-        if (
-            param.default is not inspect.Parameter.empty
-            and param.default is not PydanticUndefined
-        ):
-            default_text = f", default={param.default!r}"
-        else:
-            default_text = ""
-        doc_lines.append(f"  - {param.name} ({type_name}){default_text}: {description}")
-    doc_lines.append("")
-    doc_lines.append("Returns:")
-    return_desc = getattr(
-        function, "__return_description__", "A dictionary containing the result data."
-    )
-    doc_lines.append(f"    dict[str, Any]: {return_desc}")
-
-    initial_docstring = "\n".join(doc_lines)
-    collapsed_spaces = re.sub(r' {2,}', ' ', initial_docstring)
-    final_docstring = re.sub(r'\n{2,}', '\n', collapsed_spaces).strip()
-    function.__doc__ = final_docstring
-
     tool = VectaraTool.from_defaults(
         fn=function,
         name=tool_name,
         description=function.__doc__,
         fn_schema=fn_schema,
         tool_type=ToolType.QUERY,
+        return_direct=return_direct,
     )
     return tool
 
 
-Range = Tuple[float, float, bool, bool]  # (min, max, min_inclusive, max_inclusive)
+_PARSE_RANGE_REGEX = re.compile(
+    r"""
+    ^([\[\(])\s*            # opening bracket
+    ([+-]?\d+(\.\d*)?)\s*,  # first number
+    \s*([+-]?\d+(\.\d*)?)   # second number
+    \s*([\]\)])$            # closing bracket
+    """,
+    re.VERBOSE,
+)
 
 
-def _parse_range(val_str: str) -> Range:
+def _parse_range(val_str: str) -> Tuple[float, float, bool, bool]:
     """
     Parses '[1,10)' or '(0.5, 5]' etc.
     Returns (start, end, start_incl, end_incl) or raises ValueError.
     """
-    m = re.match(
-        r"""
-        ^([\[\(])\s*            # opening bracket
-        ([+-]?\d+(\.\d*)?)\s*,  # first number
-        \s*([+-]?\d+(\.\d*)?)   # second number
-        \s*([\]\)])$            # closing bracket
-    """,
-        val_str,
-        re.VERBOSE,
-    )
+    m = _PARSE_RANGE_REGEX.match(val_str)
     if not m:
         raise ValueError(f"Invalid range syntax: {val_str!r}")
     start_inc = m.group(1) == "["
@@ -426,7 +449,7 @@ def _parse_comparison(val_str: str) -> Tuple[str, Union[float, str, bool]]:
     raise ValueError(f"No valid comparison operator at start of {val_str!r}")
 
 
-def _build_filter_string(
+def build_filter_string(
     kwargs: Dict[str, Any], tool_args_type: Dict[str, dict], fixed_filter: str
 ) -> str:
     """

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/vectara_agentic/tools.py

@@ -22,9 +22,9 @@ from .db_tools import DatabaseTools
 from .utils import summarize_documents, is_float
 from .agent_config import AgentConfig
 from .tool_utils import (
-    _create_tool_from_dynamic_function,
-    _build_filter_string,
-    VectaraTool
+    create_tool_from_dynamic_function,
+    build_filter_string,
+    VectaraTool,
 )
 
 LI_packages = {
@@ -62,6 +62,7 @@ LI_packages = {
     },
 }
 
+
 class VectaraToolFactory:
     """
     A factory class for creating Vectara RAG tools.
@@ -108,6 +109,7 @@ class VectaraToolFactory:
         mmr_diversity_bias: float = 0.2,
         udf_expression: str = None,
         rerank_chain: List[Dict] = None,
+        return_direct: bool = False,
         save_history: bool = True,
         verbose: bool = False,
         vectara_base_url: str = "https://api.vectara.io",
@@ -142,6 +144,7 @@ class VectaraToolFactory:
                 "diversity_bias" for mmr, and "user_function" for udf).
                 If using slingshot/multilingual_reranker_v1, it must be first in the list.
             save_history (bool, optional): Whether to save the query in history.
+            return_direct (bool, optional): Whether the agent should return the tool's response directly.
             verbose (bool, optional): Whether to print verbose output.
             vectara_base_url (str, optional): The base URL for the Vectara API.
             vectara_verify_ssl (bool, optional): Whether to verify SSL certificates for the Vectara API.
@@ -177,7 +180,7 @@ class VectaraToolFactory:
                 else summarize_docs
             )
             try:
-                filter_string = _build_filter_string(
+                filter_string = build_filter_string(
                     kwargs, tool_args_type, fixed_filter
                 )
             except ValueError as e:
@@ -289,7 +292,7 @@ class VectaraToolFactory:
             + "Use this tool to search for relevant documents, not to ask questions."
         )
 
-        tool = _create_tool_from_dynamic_function(
+        tool = create_tool_from_dynamic_function(
             search_function,
             tool_name,
             search_tool_extra_desc,
@@ -300,6 +303,7 @@ class VectaraToolFactory:
             ),
             tool_args_schema,
             compact_docstring=self.compact_docstring,
+            return_direct=return_direct,
         )
         return tool
 
@@ -336,6 +340,7 @@ class VectaraToolFactory:
         include_citations: bool = True,
         save_history: bool = False,
         fcs_threshold: float = 0.0,
+        return_direct: bool = False,
         verbose: bool = False,
         vectara_base_url: str = "https://api.vectara.io",
         vectara_verify_ssl: bool = True,
@@ -388,6 +393,7 @@ class VectaraToolFactory:
             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.
+            return_direct (bool, optional): Whether the agent should return the tool's response directly.
             verbose (bool, optional): Whether to print verbose output.
             vectara_base_url (str, optional): The base URL for the Vectara API.
             vectara_verify_ssl (bool, optional): Whether to verify SSL certificates for the Vectara API.
@@ -417,7 +423,7 @@ class VectaraToolFactory:
 
             query = kwargs.pop("query")
             try:
-                filter_string = _build_filter_string(
+                filter_string = build_filter_string(
                     kwargs, tool_args_type, fixed_filter
                 )
             except ValueError as e:
@@ -468,7 +474,10 @@ class VectaraToolFactory:
             response = vectara_query_engine.query(query)
 
             if len(response.source_nodes) == 0:
-                msg = "Tool failed to generate a response since no matches were found."
+                msg = (
+                    "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,
@@ -545,13 +554,14 @@ class VectaraToolFactory:
                 description="The search query to perform, in the form of a question",
             )
 
-        tool = _create_tool_from_dynamic_function(
+        tool = create_tool_from_dynamic_function(
             rag_function,
             tool_name,
             tool_description,
             RagToolBaseParams,
             tool_args_schema,
             compact_docstring=self.compact_docstring,
+            return_direct=return_direct,
         )
         return tool
 

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/vectara_agentic/tools_catalog.py

@@ -25,7 +25,7 @@ get_headers = {
 
 def get_current_date() -> str:
     """
-    Returns: the current date (when called) as a string.
+    Returns the current date as a string.
     """
     return date.today().strftime("%A, %B %d, %Y")
 

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15/vectara_agentic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.14
+Version: 0.2.15
 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

{vectara_agentic-0.2.14 → vectara_agentic-0.2.15}/vectara_agentic.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ tests/test_agent_type.py
 tests/test_fallback.py
 tests/test_groq.py
 tests/test_private_llm.py
+tests/test_return_direct.py
 tests/test_serialization.py
 tests/test_tools.py
 tests/test_vectara_llms.py