pydantic-ai-slim 1.0.8__py3-none-any.whl → 1.0.10__py3-none-any.whl

pydantic_ai/models/anthropic.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Literal, cast, overload
 
+from pydantic import TypeAdapter
 from typing_extensions import assert_never
 
 from pydantic_ai.builtin_tools import CodeExecutionTool, WebSearchTool
@@ -60,7 +61,9 @@ try:
         BetaCitationsDelta,
         BetaCodeExecutionTool20250522Param,
         BetaCodeExecutionToolResultBlock,
+        BetaCodeExecutionToolResultBlockContent,
         BetaCodeExecutionToolResultBlockParam,
+        BetaCodeExecutionToolResultBlockParamContentParam,
         BetaContentBlock,
         BetaContentBlockParam,
         BetaImageBlockParam,
@@ -97,7 +100,9 @@ try:
         BetaToolUseBlockParam,
         BetaWebSearchTool20250305Param,
         BetaWebSearchToolResultBlock,
+        BetaWebSearchToolResultBlockContent,
         BetaWebSearchToolResultBlockParam,
+        BetaWebSearchToolResultBlockParamContentParam,
     )
     from anthropic.types.beta.beta_web_search_tool_20250305_param import UserLocation
     from anthropic.types.model_param import ModelParam
@@ -302,24 +307,12 @@ class AnthropicModel(Model):
         for item in response.content:
             if isinstance(item, BetaTextBlock):
                 items.append(TextPart(content=item.text))
-            elif isinstance(item, BetaWebSearchToolResultBlock | BetaCodeExecutionToolResultBlock):
-                items.append(
-                    BuiltinToolReturnPart(
-                        provider_name=self.system,
-                        tool_name=item.type,
-                        content=item.content,
-                        tool_call_id=item.tool_use_id,
-                    )
-                )
             elif isinstance(item, BetaServerToolUseBlock):
-                items.append(
-                    BuiltinToolCallPart(
-                        provider_name=self.system,
-                        tool_name=item.name,
-                        args=cast(dict[str, Any], item.input),
-                        tool_call_id=item.id,
-                    )
-                )
+                items.append(_map_server_tool_use_block(item, self.system))
+            elif isinstance(item, BetaWebSearchToolResultBlock):
+                items.append(_map_web_search_tool_result_block(item, self.system))
+            elif isinstance(item, BetaCodeExecutionToolResultBlock):
+                items.append(_map_code_execution_tool_result_block(item, self.system))
             elif isinstance(item, BetaRedactedThinkingBlock):
                 items.append(
                     ThinkingPart(id='redacted_thinking', content='', signature=item.data, provider_name=self.system)
@@ -485,27 +478,54 @@ class AnthropicModel(Model):
                             )
                     elif isinstance(response_part, BuiltinToolCallPart):
                         if response_part.provider_name == self.system:
-                            server_tool_use_block_param = BetaServerToolUseBlockParam(
-                                id=_guard_tool_call_id(t=response_part),
-                                type='server_tool_use',
-                                name=cast(Literal['web_search', 'code_execution'], response_part.tool_name),
-                                input=response_part.args_as_dict(),
-                            )
-                            assistant_content_params.append(server_tool_use_block_param)
+                            tool_use_id = _guard_tool_call_id(t=response_part)
+                            if response_part.tool_name == WebSearchTool.kind:
+                                server_tool_use_block_param = BetaServerToolUseBlockParam(
+                                    id=tool_use_id,
+                                    type='server_tool_use',
+                                    name='web_search',
+                                    input=response_part.args_as_dict(),
+                                )
+                                assistant_content_params.append(server_tool_use_block_param)
+                            elif response_part.tool_name == CodeExecutionTool.kind:  # pragma: no branch
+                                server_tool_use_block_param = BetaServerToolUseBlockParam(
+                                    id=tool_use_id,
+                                    type='server_tool_use',
+                                    name='code_execution',
+                                    input=response_part.args_as_dict(),
+                                )
+                                assistant_content_params.append(server_tool_use_block_param)
                     elif isinstance(response_part, BuiltinToolReturnPart):
                         if response_part.provider_name == self.system:
                             tool_use_id = _guard_tool_call_id(t=response_part)
-                            if response_part.tool_name == 'web_search_tool_result':
-                                server_tool_result_block_param = BetaWebSearchToolResultBlockParam(
-                                    tool_use_id=tool_use_id, type=response_part.tool_name, content=response_part.content
+                            if response_part.tool_name in (
+                                WebSearchTool.kind,
+                                'web_search_tool_result',  # Backward compatibility
+                            ) and isinstance(response_part.content, dict | list):
+                                assistant_content_params.append(
+                                    BetaWebSearchToolResultBlockParam(
+                                        tool_use_id=tool_use_id,
+                                        type='web_search_tool_result',
+                                        content=cast(
+                                            BetaWebSearchToolResultBlockParamContentParam,
+                                            response_part.content,  # pyright: ignore[reportUnknownMemberType]
+                                        ),
+                                    )
                                 )
-                            elif response_part.tool_name == 'code_execution_tool_result':
-                                server_tool_result_block_param = BetaCodeExecutionToolResultBlockParam(
-                                    tool_use_id=tool_use_id, type=response_part.tool_name, content=response_part.content
+                            elif response_part.tool_name in (  # pragma: no branch
+                                CodeExecutionTool.kind,
+                                'code_execution_tool_result',  # Backward compatibility
+                            ) and isinstance(response_part.content, dict):
+                                assistant_content_params.append(
+                                    BetaCodeExecutionToolResultBlockParam(
+                                        tool_use_id=tool_use_id,
+                                        type='code_execution_tool_result',
+                                        content=cast(
+                                            BetaCodeExecutionToolResultBlockParamContentParam,
+                                            response_part.content,  # pyright: ignore[reportUnknownMemberType]
+                                        ),
+                                    )
                                 )
-                            else:
-                                raise ValueError(f'Unsupported tool name: {response_part.tool_name}')
-                            assistant_content_params.append(server_tool_result_block_param)
                     else:
                         assert_never(response_part)
                 if len(assistant_content_params) > 0:
@@ -646,7 +666,7 @@ class AnthropicStreamedResponse(StreamedResponse):
                     )
                 elif isinstance(current_block, BetaToolUseBlock):
                     maybe_event = self._parts_manager.handle_tool_call_delta(
-                        vendor_part_id=current_block.id,
+                        vendor_part_id=event.index,
                         tool_name=current_block.name,
                         args=cast(dict[str, Any], current_block.input) or None,
                         tool_call_id=current_block.id,
@@ -654,7 +674,20 @@ class AnthropicStreamedResponse(StreamedResponse):
                     if maybe_event is not None:  # pragma: no branch
                         yield maybe_event
                 elif isinstance(current_block, BetaServerToolUseBlock):
-                    pass
+                    yield self._parts_manager.handle_builtin_tool_call_part(
+                        vendor_part_id=event.index,
+                        part=_map_server_tool_use_block(current_block, self.provider_name),
+                    )
+                elif isinstance(current_block, BetaWebSearchToolResultBlock):
+                    yield self._parts_manager.handle_builtin_tool_return_part(
+                        vendor_part_id=event.index,
+                        part=_map_web_search_tool_result_block(current_block, self.provider_name),
+                    )
+                elif isinstance(current_block, BetaCodeExecutionToolResultBlock):
+                    yield self._parts_manager.handle_builtin_tool_return_part(
+                        vendor_part_id=event.index,
+                        part=_map_code_execution_tool_result_block(current_block, self.provider_name),
+                    )
 
             elif isinstance(event, BetaRawContentBlockDeltaEvent):
                 if isinstance(event.delta, BetaTextDelta):
@@ -675,21 +708,13 @@ class AnthropicStreamedResponse(StreamedResponse):
                         signature=event.delta.signature,
                         provider_name=self.provider_name,
                     )
-                elif (
-                    current_block
-                    and event.delta.type == 'input_json_delta'
-                    and isinstance(current_block, BetaToolUseBlock)
-                ):  # pragma: no branch
+                elif isinstance(event.delta, BetaInputJSONDelta):
                     maybe_event = self._parts_manager.handle_tool_call_delta(
-                        vendor_part_id=current_block.id,
-                        tool_name='',
+                        vendor_part_id=event.index,
                         args=event.delta.partial_json,
-                        tool_call_id=current_block.id,
                     )
                     if maybe_event is not None:  # pragma: no branch
                         yield maybe_event
-                elif isinstance(event.delta, BetaInputJSONDelta):
-                    pass
                 # TODO(Marcelo): We need to handle citations.
                 elif isinstance(event.delta, BetaCitationsDelta):
                     pass
@@ -717,3 +742,52 @@ class AnthropicStreamedResponse(StreamedResponse):
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
         return self._timestamp
+
+
+def _map_server_tool_use_block(item: BetaServerToolUseBlock, provider_name: str) -> BuiltinToolCallPart:
+    if item.name == 'web_search':
+        return BuiltinToolCallPart(
+            provider_name=provider_name,
+            tool_name=WebSearchTool.kind,
+            args=cast(dict[str, Any], item.input) or None,
+            tool_call_id=item.id,
+        )
+    elif item.name == 'code_execution':
+        return BuiltinToolCallPart(
+            provider_name=provider_name,
+            tool_name=CodeExecutionTool.kind,
+            args=cast(dict[str, Any], item.input) or None,
+            tool_call_id=item.id,
+        )
+    else:
+        assert_never(item.name)
+
+
+web_search_tool_result_content_ta: TypeAdapter[BetaWebSearchToolResultBlockContent] = TypeAdapter(
+    BetaWebSearchToolResultBlockContent
+)
+
+
+def _map_web_search_tool_result_block(item: BetaWebSearchToolResultBlock, provider_name: str) -> BuiltinToolReturnPart:
+    return BuiltinToolReturnPart(
+        provider_name=provider_name,
+        tool_name=WebSearchTool.kind,
+        content=web_search_tool_result_content_ta.dump_python(item.content, mode='json'),
+        tool_call_id=item.tool_use_id,
+    )
+
+
+code_execution_tool_result_content_ta: TypeAdapter[BetaCodeExecutionToolResultBlockContent] = TypeAdapter(
+    BetaCodeExecutionToolResultBlockContent
+)
+
+
+def _map_code_execution_tool_result_block(
+    item: BetaCodeExecutionToolResultBlock, provider_name: str
+) -> BuiltinToolReturnPart:
+    return BuiltinToolReturnPart(
+        provider_name=provider_name,
+        tool_name=CodeExecutionTool.kind,
+        content=code_execution_tool_result_content_ta.dump_python(item.content, mode='json'),
+        tool_call_id=item.tool_use_id,
+    )

pydantic_ai/models/function.py

@@ -247,18 +247,20 @@ DeltaToolCalls: TypeAlias = dict[int, DeltaToolCall]
 DeltaThinkingCalls: TypeAlias = dict[int, DeltaThinkingPart]
 """A mapping of thinking call IDs to incremental changes."""
 
+BuiltinToolCallsReturns: TypeAlias = dict[int, BuiltinToolCallPart | BuiltinToolReturnPart]
+
 FunctionDef: TypeAlias = Callable[[list[ModelMessage], AgentInfo], ModelResponse | Awaitable[ModelResponse]]
 """A function used to generate a non-streamed response."""
 
 StreamFunctionDef: TypeAlias = Callable[
-    [list[ModelMessage], AgentInfo], AsyncIterator[str | DeltaToolCalls | DeltaThinkingCalls]
+    [list[ModelMessage], AgentInfo], AsyncIterator[str | DeltaToolCalls | DeltaThinkingCalls | BuiltinToolCallsReturns]
 ]
 """A function used to generate a streamed response.
 
-While this is defined as having return type of `AsyncIterator[str | DeltaToolCalls | DeltaThinkingCalls]`, it should
+While this is defined as having return type of `AsyncIterator[str | DeltaToolCalls | DeltaThinkingCalls | BuiltinTools]`, it should
 really be considered as `AsyncIterator[str] | AsyncIterator[DeltaToolCalls] | AsyncIterator[DeltaThinkingCalls]`,
 
-E.g. you need to yield all text, all `DeltaToolCalls`, or all `DeltaThinkingCalls`, not mix them.
+E.g. you need to yield all text, all `DeltaToolCalls`, all `DeltaThinkingCalls`, or all `BuiltinToolCallsReturns`, not mix them.
 """
 
 
@@ -267,7 +269,7 @@ class FunctionStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for [FunctionModel][pydantic_ai.models.function.FunctionModel]."""
 
     _model_name: str
-    _iter: AsyncIterator[str | DeltaToolCalls | DeltaThinkingCalls]
+    _iter: AsyncIterator[str | DeltaToolCalls | DeltaThinkingCalls | BuiltinToolCallsReturns]
     _timestamp: datetime = field(default_factory=_utils.now_utc)
 
     def __post_init__(self):
@@ -305,6 +307,16 @@ class FunctionStreamedResponse(StreamedResponse):
                         )
                         if maybe_event is not None:  # pragma: no branch
                             yield maybe_event
+                    elif isinstance(delta, BuiltinToolCallPart):
+                        if content := delta.args_as_json_str():  # pragma: no branch
+                            response_tokens = _estimate_string_tokens(content)
+                            self._usage += usage.RequestUsage(output_tokens=response_tokens)
+                        yield self._parts_manager.handle_builtin_tool_call_part(vendor_part_id=dtc_index, part=delta)
+                    elif isinstance(delta, BuiltinToolReturnPart):
+                        if content := delta.model_response_str():  # pragma: no branch
+                            response_tokens = _estimate_string_tokens(content)
+                            self._usage += usage.RequestUsage(output_tokens=response_tokens)
+                        yield self._parts_manager.handle_builtin_tool_return_part(vendor_part_id=dtc_index, part=delta)
                     else:
                         assert_never(delta)
 
@@ -351,11 +363,8 @@ def _estimate_usage(messages: Iterable[ModelMessage]) -> usage.RequestUsage:
                     response_tokens += _estimate_string_tokens(part.content)
                 elif isinstance(part, ToolCallPart):
                     response_tokens += 1 + _estimate_string_tokens(part.args_as_json_str())
-                # TODO(Marcelo): We need to add coverage here.
                 elif isinstance(part, BuiltinToolCallPart):  # pragma: no cover
-                    call = part
-                    response_tokens += 1 + _estimate_string_tokens(call.args_as_json_str())
-                # TODO(Marcelo): We need to add coverage here.
+                    response_tokens += 1 + _estimate_string_tokens(part.args_as_json_str())
                 elif isinstance(part, BuiltinToolReturnPart):  # pragma: no cover
                     response_tokens += _estimate_string_tokens(part.model_response_str())
                 else:

pydantic_ai/models/google.py

@@ -51,10 +51,15 @@ from . import (
 try:
     from google.genai import Client
     from google.genai.types import (
+        BlobDict,
+        CodeExecutionResult,
+        CodeExecutionResultDict,
         ContentDict,
         ContentUnionDict,
         CountTokensConfigDict,
+        ExecutableCode,
         ExecutableCodeDict,
+        FileDataDict,
         FinishReason as GoogleFinishReason,
         FunctionCallDict,
         FunctionCallingConfigDict,
@@ -64,6 +69,7 @@ try:
         GenerateContentResponse,
         GenerationConfigDict,
         GoogleSearchDict,
+        GroundingMetadata,
         HttpOptionsDict,
         MediaResolution,
         Part,
@@ -75,6 +81,7 @@ try:
         ToolDict,
         ToolListUnionDict,
         UrlContextDict,
+        VideoMetadataDict,
     )
 
     from ..providers.google import GoogleProvider
@@ -434,6 +441,7 @@ class GoogleModel(Model):
         usage = _metadata_as_usage(response)
         return _process_response_from_parts(
             parts,
+            candidate.grounding_metadata,
             response.model_version or self._model_name,
             self._provider.name,
             usage,
@@ -520,17 +528,17 @@ class GoogleModel(Model):
                 if isinstance(item, str):
                     content.append({'text': item})
                 elif isinstance(item, BinaryContent):
-                    # NOTE: The type from Google GenAI is incorrect, it should be `str`, not `bytes`.
-                    base64_encoded = base64.b64encode(item.data).decode('utf-8')
-                    inline_data_dict = {'inline_data': {'data': base64_encoded, 'mime_type': item.media_type}}
+                    inline_data_dict: BlobDict = {'data': item.data, 'mime_type': item.media_type}
+                    part_dict: PartDict = {'inline_data': inline_data_dict}
                     if item.vendor_metadata:
-                        inline_data_dict['video_metadata'] = item.vendor_metadata
-                    content.append(inline_data_dict)  # type: ignore
+                        part_dict['video_metadata'] = cast(VideoMetadataDict, item.vendor_metadata)
+                    content.append(part_dict)
                 elif isinstance(item, VideoUrl) and item.is_youtube:
-                    file_data_dict = {'file_data': {'file_uri': item.url, 'mime_type': item.media_type}}
+                    file_data_dict: FileDataDict = {'file_uri': item.url, 'mime_type': item.media_type}
+                    part_dict: PartDict = {'file_data': file_data_dict}
                     if item.vendor_metadata:  # pragma: no branch
-                        file_data_dict['video_metadata'] = item.vendor_metadata
-                    content.append(file_data_dict)  # type: ignore
+                        part_dict['video_metadata'] = cast(VideoMetadataDict, item.vendor_metadata)
+                    content.append(part_dict)
                 elif isinstance(item, FileUrl):
                     if item.force_download or (
                         # google-gla does not support passing file urls directly, except for youtube videos
@@ -538,13 +546,15 @@ class GoogleModel(Model):
                         self.system == 'google-gla'
                         and not item.url.startswith(r'https://generativelanguage.googleapis.com/v1beta/files')
                     ):
-                        downloaded_item = await download_item(item, data_format='base64')
-                        inline_data = {'data': downloaded_item['data'], 'mime_type': downloaded_item['data_type']}
-                        content.append({'inline_data': inline_data})  # type: ignore
+                        downloaded_item = await download_item(item, data_format='bytes')
+                        inline_data: BlobDict = {
+                            'data': downloaded_item['data'],
+                            'mime_type': downloaded_item['data_type'],
+                        }
+                        content.append({'inline_data': inline_data})
                     else:
-                        content.append(
-                            {'file_data': {'file_uri': item.url, 'mime_type': item.media_type}}
-                        )  # pragma: lax no cover
+                        file_data_dict: FileDataDict = {'file_uri': item.url, 'mime_type': item.media_type}
+                        content.append({'file_data': file_data_dict})  # pragma: lax no cover
                 else:
                     assert_never(item)
         return content
@@ -569,10 +579,13 @@ class GeminiStreamedResponse(StreamedResponse):
     _provider_name: str
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
+        code_execution_tool_call_id: str | None = None
         async for chunk in self._response:
             self._usage = _metadata_as_usage(chunk)
 
-            assert chunk.candidates is not None
+            if not chunk.candidates:
+                continue  # pragma: no cover
+
             candidate = chunk.candidates[0]
 
             if chunk.response_id:  # pragma: no branch
@@ -582,6 +595,19 @@ class GeminiStreamedResponse(StreamedResponse):
                 self.provider_details = {'finish_reason': raw_finish_reason.value}
                 self.finish_reason = _FINISH_REASON_MAP.get(raw_finish_reason)
 
+            # Google streams the grounding metadata (including the web search queries and results)
+            # _after_ the text that was generated using it, so it would show up out of order in the stream,
+            # and cause issues with the logic that doesn't consider text ahead of built-in tool calls as output.
+            # If that gets fixed (or we have a workaround), we can uncomment this:
+            # web_search_call, web_search_return = _map_grounding_metadata(
+            #     candidate.grounding_metadata, self.provider_name
+            # )
+            # if web_search_call and web_search_return:
+            #     yield self._parts_manager.handle_builtin_tool_call_part(vendor_part_id=uuid4(), part=web_search_call)
+            #     yield self._parts_manager.handle_builtin_tool_return_part(
+            #         vendor_part_id=uuid4(), part=web_search_return
+            #     )
+
             if candidate.content is None or candidate.content.parts is None:
                 if candidate.finish_reason == 'STOP':  # pragma: no cover
                     # Normal completion - skip this chunk
@@ -590,7 +616,11 @@ class GeminiStreamedResponse(StreamedResponse):
                     raise UnexpectedModelBehavior('Safety settings triggered', str(chunk))
                 else:  # pragma: no cover
                     raise UnexpectedModelBehavior('Content field missing from streaming Gemini response', str(chunk))
-            parts = candidate.content.parts or []
+
+            parts = candidate.content.parts
+            if not parts:
+                continue  # pragma: no cover
+
             for part in parts:
                 if part.thought_signature:
                     signature = base64.b64encode(part.thought_signature).decode('utf-8')
@@ -617,9 +647,21 @@ class GeminiStreamedResponse(StreamedResponse):
                     if maybe_event is not None:  # pragma: no branch
                         yield maybe_event
                 elif part.executable_code is not None:
-                    pass
+                    code_execution_tool_call_id = _utils.generate_tool_call_id()
+                    yield self._parts_manager.handle_builtin_tool_call_part(
+                        vendor_part_id=uuid4(),
+                        part=_map_executable_code(
+                            part.executable_code, self.provider_name, code_execution_tool_call_id
+                        ),
+                    )
                 elif part.code_execution_result is not None:
-                    pass
+                    assert code_execution_tool_call_id is not None
+                    yield self._parts_manager.handle_builtin_tool_return_part(
+                        vendor_part_id=uuid4(),
+                        part=_map_code_execution_result(
+                            part.code_execution_result, self.provider_name, code_execution_tool_call_id
+                        ),
+                    )
                 else:
                     assert part.function_response is not None, f'Unexpected part: {part}'  # pragma: no cover
 
@@ -639,7 +681,7 @@ class GeminiStreamedResponse(StreamedResponse):
         return self._timestamp
 
 
-def _content_model_response(m: ModelResponse, provider_name: str) -> ContentDict:
+def _content_model_response(m: ModelResponse, provider_name: str) -> ContentDict:  # noqa: C901
     parts: list[PartDict] = []
     thought_signature: bytes | None = None
     for item in m.parts:
@@ -663,12 +705,18 @@ def _content_model_response(m: ModelResponse, provider_name: str) -> ContentDict
                 part['thought'] = True
         elif isinstance(item, BuiltinToolCallPart):
             if item.provider_name == provider_name:
-                if item.tool_name == 'code_execution':  # pragma: no branch
-                    part['executable_code'] = cast(ExecutableCodeDict, item.args)
+                if item.tool_name == CodeExecutionTool.kind:
+                    part['executable_code'] = cast(ExecutableCodeDict, item.args_as_dict())
+                elif item.tool_name == WebSearchTool.kind:
+                    # Web search calls are not sent back
+                    pass
         elif isinstance(item, BuiltinToolReturnPart):
             if item.provider_name == provider_name:
-                if item.tool_name == 'code_execution':  # pragma: no branch
-                    part['code_execution_result'] = item.content
+                if item.tool_name == CodeExecutionTool.kind and isinstance(item.content, dict):
+                    part['code_execution_result'] = cast(CodeExecutionResultDict, item.content)  # pyright: ignore[reportUnknownMemberType]
+                elif item.tool_name == WebSearchTool.kind:
+                    # Web search results are not sent back
+                    pass
         else:
             assert_never(item)
 
@@ -679,6 +727,7 @@ def _content_model_response(m: ModelResponse, provider_name: str) -> ContentDict
 
 def _process_response_from_parts(
     parts: list[Part],
+    grounding_metadata: GroundingMetadata | None,
     model_name: GoogleModelName,
     provider_name: str,
     usage: usage.RequestUsage,
@@ -687,7 +736,17 @@ def _process_response_from_parts(
     finish_reason: FinishReason | None = None,
 ) -> ModelResponse:
     items: list[ModelResponsePart] = []
+
+    # We don't currently turn `candidate.url_context_metadata` into BuiltinToolCallPart and BuiltinToolReturnPart for UrlContextTool.
+    # Please file an issue if you need this.
+
+    web_search_call, web_search_return = _map_grounding_metadata(grounding_metadata, provider_name)
+    if web_search_call and web_search_return:
+        items.append(web_search_call)
+        items.append(web_search_return)
+
     item: ModelResponsePart | None = None
+    code_execution_tool_call_id: str | None = None
     for part in parts:
         if part.thought_signature:
             signature = base64.b64encode(part.thought_signature).decode('utf-8')
@@ -698,16 +757,11 @@ def _process_response_from_parts(
             item.provider_name = provider_name
 
         if part.executable_code is not None:
-            item = BuiltinToolCallPart(
-                provider_name=provider_name, args=part.executable_code.model_dump(), tool_name='code_execution'
-            )
+            code_execution_tool_call_id = _utils.generate_tool_call_id()
+            item = _map_executable_code(part.executable_code, provider_name, code_execution_tool_call_id)
         elif part.code_execution_result is not None:
-            item = BuiltinToolReturnPart(
-                provider_name=provider_name,
-                tool_name='code_execution',
-                content=part.code_execution_result,
-                tool_call_id='not_provided',
-            )
+            assert code_execution_tool_call_id is not None
+            item = _map_code_execution_result(part.code_execution_result, provider_name, code_execution_tool_call_id)
         elif part.text is not None:
             if part.thought:
                 item = ThinkingPart(content=part.text)
@@ -778,7 +832,7 @@ def _metadata_as_usage(response: GenerateContentResponse) -> usage.RequestUsage:
         if not metadata_details:
             continue
         for detail in metadata_details:
-            if not detail.modality or not detail.token_count:  # pragma: no cover
+            if not detail.modality or not detail.token_count:
                 continue
             details[f'{detail.modality.lower()}_{prefix}_tokens'] = detail.token_count
             if detail.modality != 'AUDIO':
@@ -799,3 +853,48 @@ def _metadata_as_usage(response: GenerateContentResponse) -> usage.RequestUsage:
         cache_audio_read_tokens=cache_audio_read_tokens,
         details=details,
     )
+
+
+def _map_executable_code(executable_code: ExecutableCode, provider_name: str, tool_call_id: str) -> BuiltinToolCallPart:
+    return BuiltinToolCallPart(
+        provider_name=provider_name,
+        tool_name=CodeExecutionTool.kind,
+        args=executable_code.model_dump(mode='json'),
+        tool_call_id=tool_call_id,
+    )
+
+
+def _map_code_execution_result(
+    code_execution_result: CodeExecutionResult, provider_name: str, tool_call_id: str
+) -> BuiltinToolReturnPart:
+    return BuiltinToolReturnPart(
+        provider_name=provider_name,
+        tool_name=CodeExecutionTool.kind,
+        content=code_execution_result.model_dump(mode='json'),
+        tool_call_id=tool_call_id,
+    )
+
+
+def _map_grounding_metadata(
+    grounding_metadata: GroundingMetadata | None, provider_name: str
+) -> tuple[BuiltinToolCallPart, BuiltinToolReturnPart] | tuple[None, None]:
+    if grounding_metadata and (web_search_queries := grounding_metadata.web_search_queries):
+        tool_call_id = _utils.generate_tool_call_id()
+        return (
+            BuiltinToolCallPart(
+                provider_name=provider_name,
+                tool_name=WebSearchTool.kind,
+                tool_call_id=tool_call_id,
+                args={'queries': web_search_queries},
+            ),
+            BuiltinToolReturnPart(
+                provider_name=provider_name,
+                tool_name=WebSearchTool.kind,
+                tool_call_id=tool_call_id,
+                content=[chunk.web.model_dump(mode='json') for chunk in grounding_chunks if chunk.web]
+                if (grounding_chunks := grounding_metadata.grounding_chunks)
+                else None,
+            ),
+        )
+    else:
+        return None, None