pydantic-ai-slim 0.0.27__tar.gz → 0.0.29__tar.gz

{pydantic_ai_slim-0.0.27 → pydantic_ai_slim-0.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.27
+Version: 0.0.29
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,12 +29,14 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: logfire-api>=1.2.0
-Requires-Dist: pydantic-graph==0.0.27
+Requires-Dist: pydantic-graph==0.0.29
 Requires-Dist: pydantic>=2.10
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.13.11; extra == 'cohere'
+Provides-Extra: duckduckgo
+Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: groq
 Requires-Dist: groq>=0.12.0; extra == 'groq'
 Provides-Extra: logfire
@@ -43,6 +45,8 @@ Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
 Requires-Dist: openai>=1.61.0; extra == 'openai'
+Provides-Extra: tavily
+Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: vertexai
 Requires-Dist: google-auth>=2.36.0; extra == 'vertexai'
 Requires-Dist: requests>=2.32.3; extra == 'vertexai'

{pydantic_ai_slim-0.0.27 → pydantic_ai_slim-0.0.29}/pydantic_ai/agent.py

@@ -1,6 +1,5 @@
 from __future__ import annotations as _annotations
 
-import asyncio
 import dataclasses
 import inspect
 from collections.abc import AsyncIterator, Awaitable, Iterator, Sequence
@@ -13,6 +12,7 @@ import logfire_api
 from typing_extensions import TypeVar, deprecated
 
 from pydantic_graph import BaseNode, End, Graph, GraphRun, GraphRunContext
+from pydantic_graph._utils import get_event_loop
 
 from . import (
     _agent_graph,
@@ -538,7 +538,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         """
         if infer_name and self.name is None:
             self._infer_name(inspect.currentframe())
-        return asyncio.get_event_loop().run_until_complete(
+        return get_event_loop().run_until_complete(
             self.run(
                 user_prompt,
                 result_type=result_type,

pydantic_ai_slim-0.0.29/pydantic_ai/common_tools/duckduckgo.py

@@ -0,0 +1,73 @@
+import functools
+from dataclasses import dataclass
+from typing import TypedDict
+
+import anyio
+import anyio.to_thread
+from pydantic import TypeAdapter
+
+from pydantic_ai.tools import Tool
+
+try:
+    from duckduckgo_search import DDGS
+except ImportError as _import_error:
+    raise ImportError(
+        'Please install `duckduckgo-search` to use the DuckDuckGo search tool, '
+        "you can use the `duckduckgo` optional group — `pip install 'pydantic-ai-slim[duckduckgo]'`"
+    ) from _import_error
+
+__all__ = ('duckduckgo_search_tool',)
+
+
+class DuckDuckGoResult(TypedDict):
+    """A DuckDuckGo search result."""
+
+    title: str
+    """The title of the search result."""
+    href: str
+    """The URL of the search result."""
+    body: str
+    """The body of the search result."""
+
+
+duckduckgo_ta = TypeAdapter(list[DuckDuckGoResult])
+
+
+@dataclass
+class DuckDuckGoSearchTool:
+    """The DuckDuckGo search tool."""
+
+    client: DDGS
+    """The DuckDuckGo search client."""
+
+    max_results: int | None = None
+    """The maximum number of results. If None, returns results only from the first response."""
+
+    async def __call__(self, query: str) -> list[DuckDuckGoResult]:
+        """Searches DuckDuckGo for the given query and returns the results.
+
+        Args:
+            query: The query to search for.
+
+        Returns:
+            The search results.
+        """
+        search = functools.partial(self.client.text, max_results=self.max_results)
+        results = await anyio.to_thread.run_sync(search, query)
+        if len(results) == 0:
+            raise RuntimeError('No search results found.')
+        return duckduckgo_ta.validate_python(results)
+
+
+def duckduckgo_search_tool(duckduckgo_client: DDGS | None = None, max_results: int | None = None):
+    """Creates a DuckDuckGo search tool.
+
+    Args:
+        duckduckgo_client: The DuckDuckGo search client.
+        max_results: The maximum number of results. If None, returns results only from the first response.
+    """
+    return Tool(
+        DuckDuckGoSearchTool(client=duckduckgo_client or DDGS(), max_results=max_results).__call__,
+        name='duckduckgo_search',
+        description='Searches DuckDuckGo for the given query and returns the results.',
+    )

pydantic_ai_slim-0.0.29/pydantic_ai/common_tools/tavily.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass
+from typing import Literal, TypedDict
+
+from pydantic import TypeAdapter
+
+from pydantic_ai.tools import Tool
+
+try:
+    from tavily import AsyncTavilyClient
+except ImportError as _import_error:
+    raise ImportError(
+        'Please install `tavily-python` to use the Tavily search tool, '
+        "you can use the `tavily` optional group — `pip install 'pydantic-ai-slim[tavily]'`"
+    ) from _import_error
+
+__all__ = ('tavily_search_tool',)
+
+
+class TavilySearchResult(TypedDict):
+    """A Tavily search result.
+
+    See [Tavily Search Endpoint documentation](https://docs.tavily.com/api-reference/endpoint/search)
+    for more information.
+    """
+
+    title: str
+    """The title of the search result."""
+    url: str
+    """The URL of the search result.."""
+    content: str
+    """A short description of the search result."""
+    score: float
+    """The relevance score of the search result."""
+
+
+tavily_search_ta = TypeAdapter(list[TavilySearchResult])
+
+
+@dataclass
+class TavilySearchTool:
+    """The Tavily search tool."""
+
+    client: AsyncTavilyClient
+    """The Tavily search client."""
+
+    async def __call__(
+        self,
+        query: str,
+        search_deep: Literal['basic', 'advanced'] = 'basic',
+        topic: Literal['general', 'news'] = 'general',
+        time_range: Literal['day', 'week', 'month', 'year', 'd', 'w', 'm', 'y'] | None = None,
+    ):
+        """Searches Tavily for the given query and returns the results.
+
+        Args:
+            query: The search query to execute with Tavily.
+            search_deep: The depth of the search.
+            topic: The category of the search.
+            time_range: The time range back from the current date to filter results.
+
+        Returns:
+            The search results.
+        """
+        results = await self.client.search(query, search_depth=search_deep, topic=topic, time_range=time_range)  # type: ignore[reportUnknownMemberType]
+        if not results['results']:
+            raise RuntimeError('No search results found.')
+        return tavily_search_ta.validate_python(results['results'])
+
+
+def tavily_search_tool(api_key: str):
+    """Creates a Tavily search tool.
+
+    Args:
+        api_key: The Tavily API key.
+
+            You can get one by signing up at [https://app.tavily.com/home](https://app.tavily.com/home).
+    """
+    return Tool(
+        TavilySearchTool(client=AsyncTavilyClient(api_key)).__call__,
+        name='tavily_search',
+        description='Searches Tavily for the given query and returns the results.',
+    )

{pydantic_ai_slim-0.0.27 → pydantic_ai_slim-0.0.29}/pydantic_ai/models/anthropic.py

@@ -1,5 +1,6 @@
 from __future__ import annotations as _annotations
 
+import base64
 import io
 from collections.abc import AsyncGenerator, AsyncIterable, AsyncIterator
 from contextlib import asynccontextmanager
@@ -343,12 +344,35 @@ class AnthropicModel(Model):
                     else:
                         raise RuntimeError('Only images are supported for binary content')
                 elif isinstance(item, ImageUrl):
-                    response = await cached_async_http_client().get(item.url)
-                    response.raise_for_status()
-                    yield ImageBlockParam(
-                        source={'data': io.BytesIO(response.content), 'media_type': 'image/jpeg', 'type': 'base64'},
-                        type='image',
-                    )
+                    try:
+                        response = await cached_async_http_client().get(item.url)
+                        response.raise_for_status()
+                        yield ImageBlockParam(
+                            source={
+                                'data': io.BytesIO(response.content),
+                                'media_type': item.media_type,
+                                'type': 'base64',
+                            },
+                            type='image',
+                        )
+                    except ValueError:
+                        # Download the file if can't find the mime type.
+                        client = cached_async_http_client()
+                        response = await client.get(item.url, follow_redirects=True)
+                        response.raise_for_status()
+                        base64_encoded = base64.b64encode(response.content).decode('utf-8')
+                        if (mime_type := response.headers['Content-Type']) in (
+                            'image/jpeg',
+                            'image/png',
+                            'image/gif',
+                            'image/webp',
+                        ):
+                            yield ImageBlockParam(
+                                source={'data': base64_encoded, 'media_type': mime_type, 'type': 'base64'},
+                                type='image',
+                            )
+                        else:  # pragma: no cover
+                            raise RuntimeError(f'Unsupported image type: {mime_type}')
                 else:
                     raise RuntimeError(f'Unsupported content type: {type(item)}')
 

{pydantic_ai_slim-0.0.27 → pydantic_ai_slim-0.0.29}/pydantic_ai/tools.py

@@ -49,6 +49,8 @@ class RunContext(Generic[AgentDepsT]):
     """The original user prompt passed to the run."""
     messages: list[_messages.ModelMessage] = field(default_factory=list)
     """Messages exchanged in the conversation so far."""
+    tool_call_id: str | None = None
+    """The ID of the tool call."""
     tool_name: str | None = None
     """Name of the tool being called."""
     retry: int = 0
@@ -301,7 +303,12 @@ class Tool(Generic[AgentDepsT]):
         if self._single_arg_name:
             args_dict = {self._single_arg_name: args_dict}
 
-        ctx = dataclasses.replace(run_context, retry=self.current_retry, tool_name=message.tool_name)
+        ctx = dataclasses.replace(
+            run_context,
+            retry=self.current_retry,
+            tool_name=message.tool_name,
+            tool_call_id=message.tool_call_id,
+        )
         args = [ctx] if self.takes_ctx else []
         for positional_field in self._positional_fields:
             args.append(args_dict.pop(positional_field))

{pydantic_ai_slim-0.0.27 → pydantic_ai_slim-0.0.29}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai-slim"
-version = "0.0.27"
+version = "0.0.29"
 description = "Agent Framework / shim to use Pydantic with LLMs, slim package"
 authors = [{ name = "Samuel Colvin", email = "samuel@pydantic.dev" }]
 license = "MIT"
@@ -37,19 +37,23 @@ dependencies = [
     "httpx>=0.27",
     "logfire-api>=1.2.0",
     "pydantic>=2.10",
-    "pydantic-graph==0.0.27",
+    "pydantic-graph==0.0.29",
     "exceptiongroup; python_version < '3.11'",
 ]
 
 [project.optional-dependencies]
 # WARNING if you add optional groups, please update docs/install.md
 logfire = ["logfire>=2.3"]
+# Models
 openai = ["openai>=1.61.0"]
 cohere = ["cohere>=5.13.11"]
 vertexai = ["google-auth>=2.36.0", "requests>=2.32.3"]
 anthropic = ["anthropic>=0.40.0"]
 groq = ["groq>=0.12.0"]
 mistral = ["mistralai>=1.2.5"]
+# Tools
+duckduckgo = ["duckduckgo-search>=7.0.0"]
+tavily = ["tavily-python>=0.5.0"]
 
 [dependency-groups]
 dev = [