pydantic-ai-slim 0.0.27__py3-none-any.whl → 0.0.28__py3-none-any.whl

pydantic_ai/common_tools/duckduckgo.py

@@ -0,0 +1,63 @@
+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."""
+
+    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.
+        """
+        results = await anyio.to_thread.run_sync(self.client.text, 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):
+    """Creates a DuckDuckGo search tool."""
+    return Tool(
+        DuckDuckGoSearchTool(client=duckduckgo_client or DDGS()).__call__,
+        name='duckduckgo_search',
+        description='Searches DuckDuckGo for the given query and returns the results.',
+    )

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/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/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.dist-info → pydantic_ai_slim-0.0.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.27
+Version: 0.0.28
 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.28
 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.dist-info → pydantic_ai_slim-0.0.28.dist-info}/RECORD

@@ -13,10 +13,13 @@ pydantic_ai/messages.py,sha256=U-RgeRsMR-Ew6IoeBDrnQVONX9AwxyVd0aTnAxEA7EM,20918
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/result.py,sha256=Rqbog6efO1l_bFJSuAd-_ZZLoQa_rz4motOGeR_5N3I,16803
 pydantic_ai/settings.py,sha256=ntuWnke9UA18aByDxk9OIhN0tAgOaPdqCEkRf-wlp8Y,3059
-pydantic_ai/tools.py,sha256=c6QPa3Lio5S-iC3av7rYHaxHQTH_2y5LmlL6DGLmTRk,13249
+pydantic_ai/tools.py,sha256=IPZuZJCSQUppz1uyLVwpfFLGoMirB8YtKWXIDQGR444,13414
 pydantic_ai/usage.py,sha256=60d9f6M7YEYuKMbqDGDogX4KsA73fhDtWyDXYXoIPaI,4948
+pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/common_tools/duckduckgo.py,sha256=EaAxC9qdfsS7kcCLuRl_3ijHB7zsTwTb4bFwwsJaUi8,1771
+pydantic_ai/common_tools/tavily.py,sha256=Lz35037ggkdWKa_Stj0yXBkiN_hygDefEevoRDUclF0,2560
 pydantic_ai/models/__init__.py,sha256=Qw_g58KzGUmuDKOBa2u3yFrNbgCXkdRSNtkhseLC1VM,13758
-pydantic_ai/models/anthropic.py,sha256=E194k2TgZVHPAOMmMBARlTlT4VtGAZGgiq2BTa56nEc,19398
+pydantic_ai/models/anthropic.py,sha256=bFtE6hku9L4l4pKJg8XER37T2ST2htArho5lPjEohAk,20637
 pydantic_ai/models/cohere.py,sha256=6F6eWPGVT7mpMXlRugbVbR-a8Q1zmb1SKS_fWOoBL80,11514
 pydantic_ai/models/fallback.py,sha256=smHwNIpxu19JsgYYjY0nmzl3yox7yQRJ0Ir08zdhnk0,4207
 pydantic_ai/models/function.py,sha256=EMlASu436RE-XzOTuHGkIqkS8J4WItUvwwaL08LLkX8,10948
@@ -28,6 +31,6 @@ pydantic_ai/models/openai.py,sha256=koIcK_pDHmV-JFq_-VIzU-edAqGKOOzkSk5QSYWvfoc,
 pydantic_ai/models/test.py,sha256=Ux20cmuJFkhvI9L1N7ItHNFcd-j284TBEsrM53eWRag,16873
 pydantic_ai/models/vertexai.py,sha256=9Kp_1KMBlbP8_HRJTuFnrkkFmlJ7yFhADQYjxOgIh9Y,9523
 pydantic_ai/models/wrapper.py,sha256=Zr3fgiUBpt2N9gXds6iSwaMEtEsFKr9WwhpHjSoHa7o,1410
-pydantic_ai_slim-0.0.27.dist-info/METADATA,sha256=xGhDjUz-jpvDe6I05iUbhPYb3X-1IpZWxt-j461m5hw,2894
-pydantic_ai_slim-0.0.27.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.0.27.dist-info/RECORD,,
+pydantic_ai_slim-0.0.28.dist-info/METADATA,sha256=9HxYFOYIFQoNh4uk1ca3yThzS_QTpx8nzPmfLte9Vr4,3062
+pydantic_ai_slim-0.0.28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.0.28.dist-info/RECORD,,