vectara-agentic 0.2.17__py3-none-any.whl → 0.2.18__py3-none-any.whl

tests/test_api_endpoint.py

@@ -0,0 +1,126 @@
+import unittest
+from uuid import UUID
+
+from fastapi.testclient import TestClient
+
+# Adjust this import to point at the file where you put create_app
+from vectara_agentic.agent_endpoint import create_app
+from vectara_agentic.agent import Agent
+from vectara_agentic.agent_config import AgentConfig
+
+
+class DummyAgent(Agent):
+    def __init__(self):
+        # satisfy Agent.__init__(tools: ...)
+        super().__init__(tools=[])
+
+    def chat(self, message: str) -> str:
+        return f"Echo: {message}"
+
+class APITestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.agent = DummyAgent()
+        # Override only the endpoint_api_key, leave everything else as default
+        cls.config = AgentConfig(endpoint_api_key="testkey")
+        app = create_app(cls.agent, cls.config)
+        cls.client = TestClient(app)
+        cls.headers = {"X-API-Key": cls.config.endpoint_api_key}
+
+    def test_chat_success(self):
+        r = self.client.get("/chat", params={"message": "hello"}, headers=self.headers)
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.json(), {"response": "Echo: hello"})
+
+    def test_chat_empty_message(self):
+        r = self.client.get("/chat", params={"message": ""}, headers=self.headers)
+        self.assertEqual(r.status_code, 400)
+        self.assertIn("No message provided", r.json()["detail"])
+
+    def test_chat_unauthorized(self):
+        r = self.client.get("/chat", params={"message": "hello"}, headers={"X-API-Key": "bad"})
+        self.assertEqual(r.status_code, 403)
+
+    def test_completions_success(self):
+        payload = {"model": "m1", "prompt": "test"}
+        r = self.client.post("/v1/completions", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 200)
+        data = r.json()
+
+        # ID prefix + valid UUID check
+        self.assertTrue(data["id"].startswith("cmpl-"))
+        UUID(data["id"].split("-", 1)[1])
+
+        self.assertEqual(data["model"], "m1")
+        self.assertEqual(data["choices"][0]["text"], "Echo: test")
+        # prompt_tokens=1, completion_tokens=2 ("Echo:", "test")
+        self.assertEqual(data["usage"]["prompt_tokens"], 1)
+        self.assertEqual(data["usage"]["completion_tokens"], 2)
+
+    def test_completions_no_prompt(self):
+        payload = {"model": "m1"}  # missing prompt
+        r = self.client.post("/v1/completions", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 400)
+        self.assertIn("`prompt` is required", r.json()["detail"])
+
+    def test_completions_unauthorized(self):
+        payload = {"model": "m1", "prompt": "hi"}
+        r = self.client.post("/v1/completions", json=payload, headers={"X-API-Key": "bad"})
+        self.assertEqual(r.status_code, 403)
+
+    def test_chat_completion_success(self):
+        payload = {
+            "model": "m1",
+            "messages": [{"role": "user", "content": "hello"}]
+        }
+        r = self.client.post("/v1/chat", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 200)
+        data = r.json()
+
+        # ID prefix + valid UUID check
+        self.assertTrue(data["id"].startswith("chatcmpl-"))
+        UUID(data["id"].split("-", 1)[1])
+
+        self.assertEqual(data["model"], "m1")
+        self.assertEqual(data["choices"][0]["message"]["content"], "Echo: hello")
+
+        # prompt_tokens=1, completion_tokens=2 ("Echo:", "hello")
+        self.assertEqual(data["usage"]["prompt_tokens"], 1)
+        self.assertEqual(data["usage"]["completion_tokens"], 2)
+
+    def test_chat_completion_multiple_user_messages(self):
+        payload = {
+            "model": "m1",
+            "messages": [
+                {"role": "system", "content": "ignore me"},
+                {"role": "user", "content": "foo"},
+                {"role": "assistant", "content": "pong"},
+                {"role": "user", "content": "bar"}
+            ]
+        }
+        r = self.client.post("/v1/chat", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 200)
+        data = r.json()
+
+        # Should concatenate only user messages: "foo bar"
+        self.assertEqual(data["choices"][0]["message"]["content"], "Echo: foo bar")
+        self.assertEqual(data["usage"]["prompt_tokens"], 2)   # "foo","bar"
+        self.assertEqual(data["usage"]["completion_tokens"], 3)  # "Echo:","foo","bar"
+
+    def test_chat_completion_no_messages(self):
+        payload = {"model": "m1", "messages": []}
+        r = self.client.post("/v1/chat", json=payload, headers=self.headers)
+        self.assertEqual(r.status_code, 400)
+        self.assertIn("`messages` is required", r.json()["detail"])
+
+    def test_chat_completion_unauthorized(self):
+        payload = {
+            "model": "m1",
+            "messages": [{"role": "user", "content": "oops"}]
+        }
+        r = self.client.post("/v1/chat", json=payload, headers={"X-API-Key": "bad"})
+        self.assertEqual(r.status_code, 403)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_gemini.py

@@ -0,0 +1,115 @@
+import unittest
+
+from pydantic import Field, BaseModel
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.tools import VectaraToolFactory
+from vectara_agentic.types import ModelProvider
+
+
+import nest_asyncio
+nest_asyncio.apply()
+
+tickers = {
+    "C": "Citigroup",
+    "COF": "Capital One",
+    "JPM": "JPMorgan Chase",
+    "AAPL": "Apple Computer",
+    "GOOG": "Google",
+    "AMZN": "Amazon",
+    "SNOW": "Snowflake",
+    "TEAM": "Atlassian",
+    "TSLA": "Tesla",
+    "NVDA": "Nvidia",
+    "MSFT": "Microsoft",
+    "AMD": "Advanced Micro Devices",
+    "INTC": "Intel",
+    "NFLX": "Netflix",
+    "STT": "State Street",
+    "BK": "Bank of New York Mellon",
+}
+years = list(range(2015, 2025))
+
+
+def mult(x: float, y: float) -> float:
+    "Multiply two numbers"
+    return x * y
+
+
+def get_company_info() -> list[str]:
+    """
+    Returns a dictionary of companies you can query about. Always check this before using any other tool.
+    The output is a dictionary of valid ticker symbols mapped to company names.
+    You can use this to identify the companies you can query about, and their ticker information.
+    """
+    return tickers
+
+
+def get_valid_years() -> list[str]:
+    """
+    Returns a list of the years for which financial reports are available.
+    Always check this before using any other tool.
+    """
+    return years
+
+
+fc_config_gemini = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GEMINI,
+    tool_llm_provider=ModelProvider.GEMINI,
+)
+
+
+class TestGEMINI(unittest.TestCase):
+
+    def test_tool_with_many_arguments(self):
+
+        vectara_corpus_key = "vectara-docs_1"
+        vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+
+        class QueryToolArgs(BaseModel):
+            arg1: str = Field(description="the first argument", examples=["val1"])
+            arg2: str = Field(description="the second argument", examples=["val2"])
+            arg3: str = Field(description="the third argument", examples=["val3"])
+            arg4: str = Field(description="the fourth argument", examples=["val4"])
+            arg5: str = Field(description="the fifth argument", examples=["val5"])
+            arg6: str = Field(description="the sixth argument", examples=["val6"])
+            arg7: str = Field(description="the seventh argument", examples=["val7"])
+            arg8: str = Field(description="the eighth argument", examples=["val8"])
+            arg9: str = Field(description="the ninth argument", examples=["val9"])
+            arg10: str = Field(description="the tenth argument", examples=["val10"])
+            arg11: str = Field(description="the eleventh argument", examples=["val11"])
+            arg12: str = Field(description="the twelfth argument", examples=["val12"])
+            arg13: str = Field(
+                description="the thirteenth argument", examples=["val13"]
+            )
+            arg14: str = Field(
+                description="the fourteenth argument", examples=["val14"]
+            )
+            arg15: str = Field(description="the fifteenth argument", examples=["val15"])
+
+        query_tool_1 = vec_factory.create_rag_tool(
+            tool_name="rag_tool",
+            tool_description="""
+            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
+            We are using this tool to test the tool factory works and does not crash with OpenAI.
+            """,
+            tool_args_schema=QueryToolArgs,
+        )
+
+        agent = Agent(
+            tools=[query_tool_1],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 15 arguments",
+            agent_config=fc_config_gemini,
+        )
+        res = agent.chat("What is the stock price?")
+        self.assertTrue(
+            any(sub in str(res) for sub in ["I don't know", "I do not have"])
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_groq.py

@@ -54,13 +54,6 @@ def get_valid_years() -> list[str]:
     return years
 
 
-config_gemini = AgentConfig(
-    agent_type=AgentType.FUNCTION_CALLING,
-    main_llm_provider=ModelProvider.GEMINI,
-    tool_llm_provider=ModelProvider.GEMINI,
-)
-
-
 fc_config_groq = AgentConfig(
     agent_type=AgentType.FUNCTION_CALLING,
     main_llm_provider=ModelProvider.GROQ,

tests/test_tools.py

@@ -251,17 +251,19 @@ class TestToolsPackage(unittest.TestCase):
             arg11: str = Field(description="the eleventh argument", examples=["val11"])
             arg12: str = Field(description="the twelfth argument", examples=["val12"])
             arg13: str = Field(description="the thirteenth argument", examples=["val13"])
+            arg14: str = Field(description="the fourteenth argument", examples=["val14"])
+            arg15: str = Field(description="the fifteenth argument", examples=["val15"])
 
         query_tool_1 = vec_factory.create_rag_tool(
             tool_name="rag_tool",
             tool_description="""
-            A dummy tool that takes 13 arguments and returns a response (str) to the user query based on the data in this corpus.
+            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
             We are using this tool to test the tool factory works and does not crash with OpenAI.
             """,
             tool_args_schema=QueryToolArgs,
         )
 
-        # Test with 13 arguments which go over the 1024 limit.
+        # Test with 15 arguments to make sure no issues occur
         config = AgentConfig(
             agent_type=AgentType.OPENAI
         )
@@ -272,9 +274,9 @@ class TestToolsPackage(unittest.TestCase):
             agent_config=config,
         )
         res = agent.chat("What is the stock price for Yahoo on 12/31/22?")
-        self.assertIn("maximum length of 1024 characters", str(res))
+        self.assertNotIn("maximum length of 1024 characters", str(res))
 
-        # Same test but with GROQ
+        # Same test but with GROQ, should not have this limit
         config = AgentConfig(
             agent_type=AgentType.FUNCTION_CALLING,
             main_llm_provider=ModelProvider.GROQ,
@@ -283,13 +285,13 @@ class TestToolsPackage(unittest.TestCase):
         agent = Agent(
             tools=[query_tool_1],
             topic="Sample topic",
-            custom_instructions="Call the tool with 13 arguments for GROQ",
+            custom_instructions="Call the tool with 15 arguments for GROQ",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
         self.assertNotIn("maximum length of 1024 characters", str(res))
 
-        # Same test but with ANTHROPIC
+        # Same test but with ANTHROPIC, should not have this limit
         config = AgentConfig(
             agent_type=AgentType.FUNCTION_CALLING,
             main_llm_provider=ModelProvider.ANTHROPIC,
@@ -298,38 +300,12 @@ class TestToolsPackage(unittest.TestCase):
         agent = Agent(
             tools=[query_tool_1],
             topic="Sample topic",
-            custom_instructions="Call the tool with 13 arguments for ANTHROPIC",
+            custom_instructions="Call the tool with 15 arguments for ANTHROPIC",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
-        # ANTHROPIC does not have that 1024 limit
         self.assertIn("stock price", str(res))
 
-        # But using Compact_docstring=True, we can pass 13 arguments successfully.
-        vec_factory = VectaraToolFactory(
-            vectara_corpus_key, vectara_api_key, compact_docstring=True
-        )
-        query_tool_2 = vec_factory.create_rag_tool(
-            tool_name="rag_tool",
-            tool_description="""
-            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
-            We are using this tool to test the tool factory works and doesn not crash with OpenAI.
-            """,
-            tool_args_schema=QueryToolArgs,
-        )
-
-        config = AgentConfig()
-        agent = Agent(
-            tools=[query_tool_2],
-            topic="Sample topic",
-            custom_instructions="Call the tool with 15 arguments",
-            agent_config=config,
-        )
-        res = agent.chat("What is the stock price?")
-        self.assertTrue(
-            any(sub in str(res) for sub in ["I don't know", "stock price"])
-        )
-
     def test_public_repo(self):
         vectara_corpus_key = "vectara-docs_1"
         vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.17"
+__version__ = "0.2.18"

vectara_agentic/agent_endpoint.py

@@ -1,62 +1,252 @@
 """
-This module contains functions to start the agent behind an API endpoint.
+agent_endpoint.py
 """
+
 import logging
-from fastapi import FastAPI, HTTPException, Depends
+import time
+import uuid
+from typing import Any, List, Literal, Optional, Union
+
+from fastapi import Depends, FastAPI, HTTPException
 from fastapi.security.api_key import APIKeyHeader
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 import uvicorn
 
 from .agent import Agent
 from .agent_config import AgentConfig
 
-api_key_header = APIKeyHeader(name="X-API-Key")
 
 class ChatRequest(BaseModel):
-    """
-    A request model for the chat endpoint.
-    """
+    """Request schema for the /chat endpoint."""
+
     message: str
 
 
+class CompletionRequest(BaseModel):
+    """Request schema for the /v1/completions endpoint."""
+
+    model: str
+    prompt: Optional[Union[str, List[str]]] = None
+    max_tokens: Optional[int] = Field(16, ge=1)
+    temperature: Optional[float] = Field(1.0, ge=0.0, le=2.0)
+    top_p: Optional[float] = Field(1.0, ge=0.0, le=1.0)
+    n: Optional[int] = Field(1, ge=1)
+    stop: Optional[Union[str, List[str]]] = None
+
+
+class Choice(BaseModel):
+    """Choice schema returned in CompletionResponse."""
+
+    text: str
+    index: int
+    logprobs: Optional[Any] = None
+    finish_reason: Literal["stop", "length", "error", None]
+
+
+class CompletionUsage(BaseModel):
+    """Token usage details in CompletionResponse."""
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+class CompletionResponse(BaseModel):
+    """Response schema for the /v1/completions endpoint."""
+
+    id: str
+    object: Literal["text_completion"]
+    created: int
+    model: str
+    choices: List[Choice]
+    usage: CompletionUsage
+
+
+class ChatMessage(BaseModel):
+    """Schema for individual chat messages in ChatCompletionRequest."""
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+
+class ChatCompletionRequest(BaseModel):
+    """Request schema for the /v1/chat endpoint."""
+    model: str
+    messages: List[ChatMessage]
+    temperature: Optional[float] = Field(1.0, ge=0.0, le=2.0)
+    top_p: Optional[float] = Field(1.0, ge=0.0, le=1.0)
+    n: Optional[int] = Field(1, ge=1)
+
+
+class ChatCompletionChoice(BaseModel):
+    """Choice schema returned in ChatCompletionResponse."""
+    index: int
+    message: ChatMessage
+    finish_reason: Literal["stop", "length", "error", None]
+
+
+class ChatCompletionResponse(BaseModel):
+    """Response schema for the /v1/chat endpoint."""
+    id: str
+    object: Literal["chat.completion"]
+    created: int
+    model: str
+    choices: List[ChatCompletionChoice]
+    usage: CompletionUsage
+
+
 def create_app(agent: Agent, config: AgentConfig) -> FastAPI:
     """
-    Create a FastAPI application with a chat endpoint.
+    Create and configure the FastAPI app.
+
+    Args:
+        agent (Agent): The agent instance to handle chat/completion.
+        config (AgentConfig): Configuration containing the API key.
+
+    Returns:
+        FastAPI: Configured FastAPI application.
     """
     app = FastAPI()
     logger = logging.getLogger("uvicorn.error")
     logging.basicConfig(level=logging.INFO)
-    endpoint_api_key = config.endpoint_api_key
 
-    @app.get("/chat", summary="Chat with the agent")
-    async def chat(message: str, api_key: str = Depends(api_key_header)):
-        logger.info(f"Received message: {message}")
-        if api_key != endpoint_api_key:
-            logger.warning("Unauthorized access attempt")
+    api_key_header = APIKeyHeader(name="X-API-Key")
+
+    async def _verify_api_key(api_key: str = Depends(api_key_header)):
+        """
+        Dependency that verifies the X-API-Key header.
+
+        Raises:
+            HTTPException(403): If the provided key does not match.
+
+        Returns:
+            bool: True if key is valid.
+        """
+        if api_key != config.endpoint_api_key:
             raise HTTPException(status_code=403, detail="Unauthorized")
+        return True
+
+    @app.get(
+        "/chat", summary="Chat with the agent", dependencies=[Depends(_verify_api_key)]
+    )
+    async def chat(message: str):
+        """
+        Handle GET /chat requests.
 
+        Args:
+            message (str): The user's message to the agent.
+
+        Returns:
+            dict: Contains the agent's response under 'response'.
+
+        Raises:
+            HTTPException(400): If message is empty.
+            HTTPException(500): On internal errors.
+        """
         if not message:
-            logger.error("No message provided in the request")
             raise HTTPException(status_code=400, detail="No message provided")
+        try:
+            res = agent.chat(message)
+            return {"response": res}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail="Internal server error") from e
+
+    @app.post(
+        "/v1/completions",
+        response_model=CompletionResponse,
+        dependencies=[Depends(_verify_api_key)],
+    )
+    async def completions(req: CompletionRequest):
+        """
+        Handle POST /v1/completions requests.
+
+        Args:
+            req (CompletionRequest): The completion request payload.
+
+        Returns:
+            CompletionResponse: The generated completion and usage stats.
+
+        Raises:
+            HTTPException(400): If prompt is missing.
+            HTTPException(500): On internal errors.
+        """
+        if not req.prompt:
+            raise HTTPException(status_code=400, detail="`prompt` is required")
+        raw = req.prompt if isinstance(req.prompt, str) else req.prompt[0]
+        try:
+            start = time.time()
+            text = agent.chat(raw)
+            logger.info(f"Agent returned in {time.time()-start:.2f}s")
+        except Exception as e:
+            raise HTTPException(status_code=500, detail="Internal server error") from e
+
+        p_tokens = len(raw.split())
+        c_tokens = len(text.split())
+
+        return CompletionResponse(
+            id=f"cmpl-{uuid.uuid4()}",
+            object="text_completion",
+            created=int(time.time()),
+            model=req.model,
+            choices=[Choice(text=text, index=0, logprobs=None, finish_reason="stop")],
+            usage=CompletionUsage(
+                prompt_tokens=p_tokens,
+                completion_tokens=c_tokens,
+                total_tokens=p_tokens + c_tokens,
+            ),
+        )
+
+    @app.post(
+        "/v1/chat",
+        response_model=ChatCompletionResponse,
+        dependencies=[Depends(_verify_api_key)],
+    )
+    async def chat_completion(req: ChatCompletionRequest):
+        if not req.messages:
+            raise HTTPException(status_code=400, detail="`messages` is required")
+
+        # concatenate all user messages into a single prompt
+        raw = " ".join(m.content for m in req.messages if m.role == "user")
 
         try:
-            response = agent.chat(message)
-            logger.info(f"Generated response: {response}")
-            return {"response": response}
+            start = time.time()
+            text = agent.chat(raw)
+            logger.info(f"Agent returned in {time.time()-start:.2f}s")
         except Exception as e:
-            logger.error(f"Error during agent processing: {e}")
             raise HTTPException(status_code=500, detail="Internal server error") from e
 
+        p_tokens = len(raw.split())
+        c_tokens = len(text.split())
+
+        return ChatCompletionResponse(
+            id=f"chatcmpl-{uuid.uuid4()}",
+            object="chat.completion",
+            created=int(time.time()),
+            model=req.model,
+            choices=[
+                ChatCompletionChoice(
+                    index=0,
+                    message=ChatMessage(role="assistant", content=text),
+                    finish_reason="stop",
+                )
+            ],
+            usage=CompletionUsage(
+                prompt_tokens=p_tokens,
+                completion_tokens=c_tokens,
+                total_tokens=p_tokens + c_tokens,
+            ),
+        )
+
     return app
 
 
-def start_app(agent: Agent, host='0.0.0.0', port=8000):
+def start_app(agent: Agent, host="0.0.0.0", port=8000):
     """
-    Start the FastAPI server.
+    Launch the FastAPI application using Uvicorn.
 
     Args:
-        host (str, optional): The host address for the API. Defaults to '127.0.0.1'.
-        port (int, optional): The port for the API. Defaults to 8000.
+        agent (Agent): The agent instance for request handling.
+        host (str, optional): Host interface. Defaults to "0.0.0.0".
+        port (int, optional): Port number. Defaults to 8000.
     """
     app = create_app(agent, config=AgentConfig())
     uvicorn.run(app, host=host, port=port)

vectara_agentic/llm_utils.py

@@ -1,7 +1,6 @@
 """
 Utilities for the Vectara agentic.
 """
-from types import MethodType
 from typing import Tuple, Callable, Optional
 from functools import lru_cache
 import tiktoken
@@ -12,7 +11,6 @@ from llama_index.llms.anthropic import Anthropic
 
 from .types import LLMRole, AgentType, ModelProvider
 from .agent_config import AgentConfig
-from .tool_utils import _updated_openai_prepare_chat_with_tools
 
 provider_to_default_model_name = {
     ModelProvider.OPENAI: "gpt-4o",
@@ -124,11 +122,6 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             is_function_calling_model=True,
             max_tokens=max_tokens,
         )
-        # pylint: disable=protected-access
-        llm._prepare_chat_with_tools = MethodType(
-            _updated_openai_prepare_chat_with_tools,
-            llm,
-        )
     elif model_provider == ModelProvider.GROQ:
         from llama_index.llms.groq import Groq
 
@@ -138,11 +131,6 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             is_function_calling_model=True,
             max_tokens=max_tokens,
         )
-        # pylint: disable=protected-access
-        llm._prepare_chat_with_tools = MethodType(
-            _updated_openai_prepare_chat_with_tools,
-            llm,
-        )
     elif model_provider == ModelProvider.FIREWORKS:
         from llama_index.llms.fireworks import Fireworks
 
@@ -167,11 +155,6 @@ def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
             api_key=config.private_llm_api_key,
             max_tokens=max_tokens,
         )
-        # pylint: disable=protected-access
-        llm._prepare_chat_with_tools = MethodType(
-            _updated_openai_prepare_chat_with_tools,
-            llm,
-        )
 
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")

vectara_agentic/tool_utils.py

@@ -7,7 +7,7 @@ import re
 
 from typing import (
     Callable, List, Dict, Any, Optional, Union, Type, Tuple,
-    Sequence, get_origin, get_args
+    get_origin, get_args
 )
 from pydantic import BaseModel, create_model
 from pydantic_core import PydanticUndefined
@@ -17,52 +17,10 @@ from llama_index.core.tools.function_tool import AsyncCallable
 from llama_index.core.tools.types import ToolMetadata, ToolOutput
 from llama_index.core.workflow.context import Context
 
-from llama_index.core.tools.types import BaseTool
-from llama_index.core.base.llms.types import ChatMessage, MessageRole
-from llama_index.llms.openai.utils import resolve_tool_choice
-
 from .types import ToolType
 from .utils import is_float
 
 
-def _updated_openai_prepare_chat_with_tools(
-    self,
-    tools: Sequence["BaseTool"],
-    user_msg: Optional[Union[str, ChatMessage]] = None,
-    chat_history: Optional[List[ChatMessage]] = None,
-    verbose: bool = False,
-    allow_parallel_tool_calls: bool = False,
-    tool_choice: Union[str, dict] = "auto",
-    strict: Optional[bool] = None,
-    **kwargs: Any,
-) -> Dict[str, Any]:
-    """Predict and call the tool."""
-    tool_specs = [tool.metadata.to_openai_tool(skip_length_check=True) for tool in tools]
-
-    # if strict is passed in, use, else default to the class-level attribute, else default to True`
-    strict = strict if strict is not None else self.strict
-
-    if self.metadata.is_function_calling_model:
-        for tool_spec in tool_specs:
-            if tool_spec["type"] == "function":
-                tool_spec["function"]["strict"] = strict
-                # in current openai 1.40.0 it is always false.
-                tool_spec["function"]["parameters"]["additionalProperties"] = False
-
-    if isinstance(user_msg, str):
-        user_msg = ChatMessage(role=MessageRole.USER, content=user_msg)
-
-    messages = chat_history or []
-    if user_msg:
-        messages.append(user_msg)
-
-    return {
-        "messages": messages,
-        "tools": tool_specs or None,
-        "tool_choice": resolve_tool_choice(tool_choice) if tool_specs else None,
-        **kwargs,
-    }
-
 class VectaraToolMetadata(ToolMetadata):
     """
     A subclass of ToolMetadata adding the tool_type attribute.

{vectara_agentic-0.2.17.dist-info → vectara_agentic-0.2.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.17
+Version: 0.2.18
 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
@@ -20,8 +20,9 @@ Requires-Dist: llama-index==0.12.35
 Requires-Dist: llama-index-indices-managed-vectara==0.4.5
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0
-Requires-Dist: llama-index-agent-openai==0.4.7
-Requires-Dist: llama-index-llms-openai==0.3.38
+Requires-Dist: llama-index-agent-openai==0.4.8
+Requires-Dist: llama-index-llms-openai==0.3.42
+Requires-Dist: llama-index-llms-openai-like>=0.3.5
 Requires-Dist: llama-index-llms-anthropic==0.6.10
 Requires-Dist: llama-index-llms-together==0.3.1
 Requires-Dist: llama-index-llms-groq==0.3.1

{vectara_agentic-0.2.17.dist-info → vectara_agentic-0.2.18.dist-info}/RECORD

@@ -3,32 +3,34 @@ tests/endpoint.py,sha256=frnpdZQpnuQNNKNYgAn2rFTarNG8MCJaNA77Bw_W22A,1420
 tests/test_agent.py,sha256=o5U3K1AJllsSDvucrgFJPQRdAmHPq3LCuFpsnECUTFk,5483
 tests/test_agent_planning.py,sha256=JwEebGooROAvsQ9JZoaH6KEcrSyv1F0lL4TD4FjP8a8,2213
 tests/test_agent_type.py,sha256=mWo-pTQNDj4fWFPETm5jnb7Y5N48aW35keTVvxdIaCc,7173
+tests/test_api_endpoint.py,sha256=M9YGFCy_Jphzq9JznP4ftHqxZ_yu6dgWdX1jRvdsORA,5002
 tests/test_fallback.py,sha256=M5YD7NHZ0joVU1frYIr9_OiRAIje5mrXrYVcekzlyGs,2829
-tests/test_groq.py,sha256=Knsz-xEBY-eoq8T0DzAC09UJWZqwtLmcjbx6QY37rJg,4235
+tests/test_gemini.py,sha256=QUBYWhZkX9AjnhPn5qa7sREf6YHZWeJEmYzKwVC23Io,4081
+tests/test_groq.py,sha256=5RA6uFC6qra-Do55f6HUotk3EQqOosw0GjOGiHDBS4o,4071
 tests/test_private_llm.py,sha256=CY-_rCpxGUuxnZ3ypkodw5Jj-sJCNdh6rLbCvULwuJI,2247
 tests/test_return_direct.py,sha256=Y_K_v88eS_kJfxE6A0Yghma0nUT8u6COitj0SNnZGNs,1523
 tests/test_serialization.py,sha256=Ed23GN2zhSJNdPFrVK4aqLkOhJKviczR_o0t-r9TuRI,4762
-tests/test_tools.py,sha256=MWExM3n1oKmVpLmayIgHXqF6_hOPq44KPkRphitBKik,15709
+tests/test_tools.py,sha256=sCgV74LZSRU1zKBhv_emUNe1ZmWIeGVrelNXpd9UV1c,14872
 tests/test_vectara_llms.py,sha256=m-fDAamJR1I5IdV0IpXuTegerTUNCVRm27lsHd4wQjg,2367
 tests/test_workflow.py,sha256=06NvgUQMzPb2b2mrxtVo7xribZEDQM1LdcXNJdiOfPc,4391
 vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
 vectara_agentic/_callback.py,sha256=ron49t1t-ox-736WaXzrZ99vhN4NI9bMiHFyj0iIPqg,13062
 vectara_agentic/_observability.py,sha256=UbJxiOJFOdLq3b1t0-Y7swMC3BzJu3IOlTUM-c1oUk8,4328
 vectara_agentic/_prompts.py,sha256=vAb02oahA7GKRgLOsDGqgKl-BLBop2AjOlCTgLrf3M4,9694
-vectara_agentic/_version.py,sha256=o3KLIOSUALmaTPqzIK1UP5BKpJQc99yysN5Rcv3m8Qk,66
+vectara_agentic/_version.py,sha256=6bWhPhOhATgGaKBsmcgPdRKvZBguw3zZOhD6CJaNJPs,66
 vectara_agentic/agent.py,sha256=zJ7ucFf8jc0VO4mTFqujfwREz2B-rJCpIgCJKAtNlEk,54884
 vectara_agentic/agent_config.py,sha256=E-rtYMcpoGxnEAyy8231bizo2n0uGQ2qWxuSgTEfwdQ,4327
-vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
+vectara_agentic/agent_endpoint.py,sha256=PzIN7HhEHv8Mq_Zo5cZ2xYrgdv2AN6kx6dc_2AJq28I,7497
 vectara_agentic/db_tools.py,sha256=Kfz6n-rSj5TQEbAiJnWGmqWtcwB0A5GpxD7d1UwGzlc,11194
-vectara_agentic/llm_utils.py,sha256=FOQG6if6D7l1eVRx_r-HSUhh5wBguIaxsYMKrZl2fJo,6302
+vectara_agentic/llm_utils.py,sha256=_dkxA9DcBwyIzg-BOTi7NwZZhhjV5G2cnaVlzd9J7do,5687
 vectara_agentic/sub_query_workflow.py,sha256=cPeossVPFajpSAwy45fSXhTXbQOfzv_l66pxSa4molM,12366
-vectara_agentic/tool_utils.py,sha256=fQFjbWc-ucHRiQ06vTbvNma7gwxYLKMAL41KZm4_MLs,20506
+vectara_agentic/tool_utils.py,sha256=jv98vCMYb9afFa-HaPxI2A8BXxplfQRv2Z9b5w7ztZc,18919
 vectara_agentic/tools.py,sha256=2_9YBqszFqYDpvlTIZfdfplRKffe660jQRxp0akM-cE,32918
 vectara_agentic/tools_catalog.py,sha256=cAN_kDOWZUoW4GNFwY5GdS6ImMUQNnF2sggx9OGK9Cg,4906
 vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
 vectara_agentic/utils.py,sha256=R9HitEG5K3Q_p2M_teosT181OUxkhs1-hnj98qDYGbE,2545
-vectara_agentic-0.2.17.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.17.dist-info/METADATA,sha256=uqgVpTya69UeykCim5Ur-V-r3tFSqJPMMYLDnKZHagk,29895
-vectara_agentic-0.2.17.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-vectara_agentic-0.2.17.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.17.dist-info/RECORD,,
+vectara_agentic-0.2.18.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.18.dist-info/METADATA,sha256=FO_4pmBWrl_-7DWPWF32HwOHbbicHdB86YvRi4cA67Y,29946
+vectara_agentic-0.2.18.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+vectara_agentic-0.2.18.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.18.dist-info/RECORD,,

{vectara_agentic-0.2.17.dist-info → vectara_agentic-0.2.18.dist-info}/WHEEL

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