inspect-ai 0.3.69__py3-none-any.whl → 0.3.71__py3-none-any.whl

inspect_ai/model/_providers/anthropic.py

@@ -1,10 +1,13 @@
 import functools
 import os
+import re
 import sys
 from copy import copy
 from logging import getLogger
 from typing import Any, Literal, Tuple, TypedDict, cast
 
+from .util.tracker import HttpxTimeTracker
+
 if sys.version_info >= (3, 11):
     from typing import NotRequired
 else:
@@ -26,8 +29,12 @@ from anthropic.types import (
     ImageBlockParam,
     Message,
     MessageParam,
+    RedactedThinkingBlock,
+    RedactedThinkingBlockParam,
     TextBlock,
     TextBlockParam,
+    ThinkingBlock,
+    ThinkingBlockParam,
     ToolParam,
     ToolResultBlockParam,
     ToolUseBlock,
@@ -42,7 +49,12 @@ from inspect_ai._util.constants import (
     DEFAULT_MAX_RETRIES,
     NO_CONTENT,
 )
-from inspect_ai._util.content import Content, ContentImage, ContentText
+from inspect_ai._util.content import (
+    Content,
+    ContentImage,
+    ContentReasoning,
+    ContentText,
+)
 from inspect_ai._util.error import exception_message
 from inspect_ai._util.images import file_as_data_uri
 from inspect_ai._util.logger import warn_once
@@ -150,6 +162,9 @@ class AnthropicAPI(ModelAPI):
                 **model_args,
             )
 
+        # create time tracker
+        self._time_tracker = HttpxTimeTracker(self.client._client)
+
     @override
     async def close(self) -> None:
         await self.client.close()
@@ -167,6 +182,9 @@ class AnthropicAPI(ModelAPI):
         tool_choice: ToolChoice,
         config: GenerateConfig,
     ) -> ModelOutput | tuple[ModelOutput | Exception, ModelCall]:
+        # allocate request_id (so we can see it from ModelCall)
+        request_id = self._time_tracker.start_request()
+
         # setup request and response for ModelCall
         request: dict[str, Any] = {}
         response: dict[str, Any] = {}
@@ -176,6 +194,7 @@ class AnthropicAPI(ModelAPI):
                 request=request,
                 response=response,
                 filter=model_call_filter,
+                time=self._time_tracker.end_request(request_id),
             )
 
         # generate
@@ -195,21 +214,33 @@ class AnthropicAPI(ModelAPI):
                 request["system"] = system_param
             request["tools"] = tools_param
             if len(tools) > 0:
-                request["tool_choice"] = message_tool_choice(tool_choice)
+                request["tool_choice"] = message_tool_choice(
+                    tool_choice, self.is_using_thinking(config)
+                )
 
             # additional options
-            request = request | self.completion_params(config)
+            req, headers, betas = self.completion_config(config)
+            request = request | req
 
-            # computer use beta
+            # extra headers (for time tracker and computer use)
+            extra_headers = headers | {HttpxTimeTracker.REQUEST_ID_HEADER: request_id}
             if computer_use:
-                request["extra_headers"] = {"anthropic-beta": "computer-use-2024-10-22"}
+                betas.append("computer-use-2024-10-22")
+            if len(betas) > 0:
+                extra_headers["anthropic-beta"] = ",".join(betas)
+
+            request["extra_headers"] = extra_headers
 
             # extra_body
             if self.extra_body is not None:
                 request["extra_body"] = self.extra_body
 
-            # make request
-            message = await self.client.messages.create(**request, stream=False)
+            # make request (stream if we are using reasoning)
+            if self.is_using_thinking(config):
+                async with self.client.messages.stream(**request) as stream:
+                    message = await stream.get_final_message()
+            else:
+                message = await self.client.messages.create(**request, stream=False)
 
             # set response for ModelCall
             response = message.model_dump()
@@ -234,27 +265,67 @@ class AnthropicAPI(ModelAPI):
             else:
                 raise ex
 
-    def completion_params(self, config: GenerateConfig) -> dict[str, Any]:
-        params = dict(model=self.model_name, max_tokens=cast(int, config.max_tokens))
-        if config.temperature is not None:
-            params["temperature"] = config.temperature
-        if config.top_p is not None:
-            params["top_p"] = config.top_p
-        if config.top_k is not None:
-            params["top_k"] = config.top_k
+    def completion_config(
+        self, config: GenerateConfig
+    ) -> tuple[dict[str, Any], dict[str, str], list[str]]:
+        max_tokens = cast(int, config.max_tokens)
+        params = dict(model=self.model_name, max_tokens=max_tokens)
+        headers: dict[str, str] = {}
+        betas: list[str] = []
+        # some params not compatible with thinking models
+        if not self.is_using_thinking(config):
+            if config.temperature is not None:
+                params["temperature"] = config.temperature
+            if config.top_p is not None:
+                params["top_p"] = config.top_p
+            if config.top_k is not None:
+                params["top_k"] = config.top_k
+
+        # some thinking-only stuff
+        if self.is_using_thinking(config):
+            params["thinking"] = dict(
+                type="enabled", budget_tokens=config.reasoning_tokens
+            )
+            headers["anthropic-version"] = "2023-06-01"
+            if max_tokens > 8192:
+                betas.append("output-128k-2025-02-19")
+
+        # config that applies to all models
         if config.timeout is not None:
             params["timeout"] = float(config.timeout)
         if config.stop_seqs is not None:
             params["stop_sequences"] = config.stop_seqs
-        return params
+
+        # return config
+        return params, headers, betas
 
     @override
     def max_tokens(self) -> int | None:
         # anthropic requires you to explicitly specify max_tokens (most others
         # set it to the maximum allowable output tokens for the model).
-        # set to 4096 which is the lowest documented max_tokens for claude models
+        # set to 4096 which is the highest possible for claude 3 (claude 3.5
+        # allows up to 8192)
         return 4096
 
+    @override
+    def max_tokens_for_config(self, config: GenerateConfig) -> int | None:
+        max_tokens = cast(int, self.max_tokens())
+        if self.is_thinking_model() and config.reasoning_tokens is not None:
+            max_tokens = max_tokens + config.reasoning_tokens
+        return max_tokens
+
+    def is_using_thinking(self, config: GenerateConfig) -> bool:
+        return self.is_thinking_model() and config.reasoning_tokens is not None
+
+    def is_thinking_model(self) -> bool:
+        return not self.is_claude_3() and not self.is_claude_3_5()
+
+    def is_claude_3(self) -> bool:
+        return re.search(r"claude-3-[a-zA-Z]", self.model_name) is not None
+
+    def is_claude_3_5(self) -> bool:
+        return "claude-3-5-" in self.model_name
+
     @override
     def connection_key(self) -> str:
         return str(self.api_key)
@@ -284,6 +355,14 @@ class AnthropicAPI(ModelAPI):
     def tool_result_images(self) -> bool:
         return True
 
+    @override
+    def emulate_reasoning_history(self) -> bool:
+        return False
+
+    @override
+    def force_reasoning_history(self) -> Literal["none", "all", "last"] | None:
+        return "all"
+
     # convert some common BadRequestError states into 'refusal' model output
     def handle_bad_request(self, ex: BadRequestError) -> ModelOutput | Exception:
         error = exception_message(ex).lower()
@@ -487,7 +566,7 @@ def combine_messages(a: MessageParam, b: MessageParam) -> MessageParam:
     role = a["role"]
     a_content = a["content"]
     b_content = b["content"]
-    if isinstance(a_content, str) and isinstance(a_content, str):
+    if isinstance(a_content, str) and isinstance(b_content, str):
         return MessageParam(role=role, content=f"{a_content}\n{b_content}")
     elif isinstance(a_content, list) and isinstance(b_content, list):
         return MessageParam(role=role, content=a_content + b_content)
@@ -503,9 +582,15 @@ def combine_messages(a: MessageParam, b: MessageParam) -> MessageParam:
         raise ValueError(f"Unexpected content types for messages: {a}, {b}")
 
 
-def message_tool_choice(tool_choice: ToolChoice) -> message_create_params.ToolChoice:
+def message_tool_choice(
+    tool_choice: ToolChoice, thinking_model: bool
+) -> message_create_params.ToolChoice:
     if isinstance(tool_choice, ToolFunction):
-        return {"type": "tool", "name": tool_choice.name}
+        # forced tool use not compatible with thinking models
+        if thinking_model:
+            return {"type": "any"}
+        else:
+            return {"type": "tool", "name": tool_choice.name}
     elif tool_choice == "any":
         return {"type": "any"}
     elif tool_choice == "none":
@@ -533,9 +618,15 @@ async def message_param(message: ChatMessage) -> MessageParam:
     # "tool" means serving a tool call result back to claude
     elif message.role == "tool":
         if message.error is not None:
-            content: str | list[TextBlockParam | ImageBlockParam] = (
-                message.error.message
-            )
+            content: (
+                str
+                | list[
+                    TextBlockParam
+                    | ImageBlockParam
+                    | ThinkingBlockParam
+                    | RedactedThinkingBlockParam
+                ]
+            ) = message.error.message
             # anthropic requires that content be populated when
             # is_error is true (throws bad_request_error when not)
             # so make sure this precondition is met
@@ -556,7 +647,7 @@ async def message_param(message: ChatMessage) -> MessageParam:
                 ToolResultBlockParam(
                     tool_use_id=str(message.tool_call_id),
                     type="tool_result",
-                    content=content,
+                    content=cast(list[TextBlockParam | ImageBlockParam], content),
                     is_error=message.error is not None,
                 )
             ],
@@ -565,7 +656,13 @@ async def message_param(message: ChatMessage) -> MessageParam:
     # tool_calls means claude is attempting to call our tools
     elif message.role == "assistant" and message.tool_calls:
         # first include content (claude <thinking>)
-        tools_content: list[TextBlockParam | ImageBlockParam | ToolUseBlockParam] = (
+        tools_content: list[
+            TextBlockParam
+            | ThinkingBlockParam
+            | RedactedThinkingBlockParam
+            | ImageBlockParam
+            | ToolUseBlockParam
+        ] = (
             [TextBlockParam(type="text", text=message.content or NO_CONTENT)]
             if isinstance(message.content, str)
             else (
@@ -634,6 +731,16 @@ def model_output_from_message(message: Message, tools: list[ToolInfo]) -> ModelO
                     arguments=content_block.model_dump().get("input", {}),
                 )
             )
+        elif isinstance(content_block, RedactedThinkingBlock):
+            content.append(
+                ContentReasoning(reasoning=content_block.data, redacted=True)
+            )
+        elif isinstance(content_block, ThinkingBlock):
+            content.append(
+                ContentReasoning(
+                    reasoning=content_block.thinking, signature=content_block.signature
+                )
+            )
 
     # resolve choice
     choice = ChatCompletionChoice(
@@ -691,7 +798,7 @@ def split_system_messages(
 
 async def message_param_content(
     content: Content,
-) -> TextBlockParam | ImageBlockParam:
+) -> TextBlockParam | ImageBlockParam | ThinkingBlockParam | RedactedThinkingBlockParam:
     if isinstance(content, ContentText):
         return TextBlockParam(type="text", text=content.text or NO_CONTENT)
     elif isinstance(content, ContentImage):
@@ -709,6 +816,18 @@ async def message_param_content(
             type="image",
             source=dict(type="base64", media_type=cast(Any, media_type), data=image),
         )
+    elif isinstance(content, ContentReasoning):
+        if content.redacted:
+            return RedactedThinkingBlockParam(
+                type="redacted_thinking",
+                data=content.reasoning,
+            )
+        else:
+            if content.signature is None:
+                raise ValueError("Thinking content without signature.")
+            return ThinkingBlockParam(
+                type="thinking", thinking=content.reasoning, signature=content.signature
+            )
     else:
         raise RuntimeError(
             "Anthropic models do not currently support audio or video inputs."

inspect_ai/model/_providers/bedrock.py

@@ -31,6 +31,7 @@ from .._model_output import ChatCompletionChoice, ModelOutput, ModelUsage
 from .util import (
     model_base_url,
 )
+from .util.tracker import BotoTimeTracker
 
 # Model for Bedrock Converse API (Response)
 # generated from: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-runtime/client/converse.html#converse
@@ -256,6 +257,9 @@ class BedrockAPI(ModelAPI):
             # Create a shared session to be used when generating
             self.session = aioboto3.Session()
 
+            # create time tracker
+            self._time_tracker = BotoTimeTracker(self.session)
+
         except ImportError:
             raise pip_dependency_error("Bedrock API", ["aioboto3"])
 
@@ -313,6 +317,7 @@ class BedrockAPI(ModelAPI):
         from botocore.exceptions import ClientError
 
         # The bedrock client
+        request_id = self._time_tracker.start_request()
         async with self.session.client(  # type: ignore[call-overload]
             service_name="bedrock-runtime",
             endpoint_url=self.base_url,
@@ -325,6 +330,7 @@ class BedrockAPI(ModelAPI):
                     else DEFAULT_MAX_RETRIES,
                     mode="adaptive",
                 ),
+                user_agent_extra=self._time_tracker.user_agent_extra(request_id),
             ),
             **self.model_args,
         ) as client:
@@ -364,6 +370,7 @@ class BedrockAPI(ModelAPI):
                         request.model_dump(exclude_none=True)
                     ),
                     response=response,
+                    time=self._time_tracker.end_request(request_id),
                 )
 
             try:

inspect_ai/model/_providers/cloudflare.py

@@ -19,6 +19,7 @@ from .util import (
     is_chat_api_rate_limit,
     model_base_url,
 )
+from .util.tracker import HttpxTimeTracker
 
 # https://developers.cloudflare.com/workers-ai/models/#text-generation
 
@@ -50,6 +51,7 @@ class CloudFlareAPI(ModelAPI):
             if not self.api_key:
                 raise environment_prerequisite_error("CloudFlare", CLOUDFLARE_API_TOKEN)
         self.client = httpx.AsyncClient()
+        self._time_tracker = HttpxTimeTracker(self.client)
         base_url = model_base_url(base_url, "CLOUDFLARE_BASE_URL")
         self.base_url = (
             base_url if base_url else "https://api.cloudflare.com/client/v4/accounts"
@@ -76,12 +78,28 @@ class CloudFlareAPI(ModelAPI):
             json["max_tokens"] = config.max_tokens
         json["messages"] = chat_api_input(input, tools, self.chat_api_handler())
 
+        # request_id
+        request_id = self._time_tracker.start_request()
+
+        # setup response
+        response: dict[str, Any] = {}
+
+        def model_call() -> ModelCall:
+            return ModelCall.create(
+                request=json,
+                response=response,
+                time=self._time_tracker.end_request(request_id),
+            )
+
         # make the call
         response = await chat_api_request(
             self.client,
             model_name=self.model_name,
             url=f"{chat_url}/{self.model_name}",
-            headers={"Authorization": f"Bearer {self.api_key}"},
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                HttpxTimeTracker.REQUEST_ID_HEADER: request_id,
+            },
             json=json,
             config=config,
         )
@@ -102,13 +120,8 @@ class CloudFlareAPI(ModelAPI):
                 ],
             )
 
-            # record call
-            call = ModelCall.create(
-                request=dict(model_name=self.model_name, **json), response=response
-            )
-
             # return
-            return output, call
+            return output, model_call()
         else:
             error = str(response.get("errors", "Unknown"))
             raise RuntimeError(f"Error calling {self.model_name}: {error}")

inspect_ai/model/_providers/google.py

@@ -38,10 +38,13 @@ from pydantic import JsonValue
 from typing_extensions import override
 
 from inspect_ai._util.constants import BASE_64_DATA_REMOVED, NO_CONTENT
-from inspect_ai._util.content import Content as InspectContent
+from inspect_ai._util.content import (
+    Content as InspectContent,
+)
 from inspect_ai._util.content import (
     ContentAudio,
     ContentImage,
+    ContentReasoning,
     ContentText,
     ContentVideo,
 )
@@ -229,6 +232,8 @@ class GoogleGenAIAPI(ModelAPI):
                 response=response,
             )
 
+        # TODO: would need to monkey patch AuthorizedSession.request
+
         try:
             response = await self.client.aio.models.generate_content(
                 model=self.model_name,
@@ -248,7 +253,10 @@ class GoogleGenAIAPI(ModelAPI):
 
     @override
     def is_rate_limit(self, ex: BaseException) -> bool:
-        return isinstance(ex, APIError) and ex.code in (429, 500, 503, 504)
+        # see https://cloud.google.com/storage/docs/retry-strategy
+        return isinstance(ex, APIError) and (
+            ex.code in (408, 429, 429) or ex.code >= 500
+        )
 
     @override
     def connection_key(self) -> str:
@@ -403,6 +411,8 @@ async def content_part(client: Client, content: InspectContent | str) -> Part:
         return Part.from_text(text=content or NO_CONTENT)
     elif isinstance(content, ContentText):
         return Part.from_text(text=content.text or NO_CONTENT)
+    elif isinstance(content, ContentReasoning):
+        return Part.from_text(text=content.reasoning or NO_CONTENT)
     else:
         return await chat_content_to_part(client, content)
 
@@ -415,7 +425,8 @@ async def chat_content_to_part(
         content_bytes, mime_type = await file_as_data(content.image)
         return Part.from_bytes(mime_type=mime_type, data=content_bytes)
     else:
-        return await file_for_content(client, content)
+        file = await file_for_content(client, content)
+        return Part.from_uri(file_uri=file.uri, mime_type=file.mime_type)
 
 
 async def extract_system_message_as_parts(
@@ -550,11 +561,19 @@ def completion_choice_from_candidate(candidate: Candidate) -> ChatCompletionChoi
     # stop reason
     stop_reason = finish_reason_to_stop_reason(candidate.finish_reason)
 
+    # choice content may include reasoning
+    if reasoning:
+        choice_content: str | list[Content] = [
+            ContentReasoning(reasoning=reasoning),
+            ContentText(text=content),
+        ]
+    else:
+        choice_content = content
+
     # build choice
     choice = ChatCompletionChoice(
         message=ChatMessageAssistant(
-            content=content,
-            reasoning=reasoning,
+            content=choice_content,
             tool_calls=tool_calls if len(tool_calls) > 0 else None,
             source="generate",
         ),
@@ -740,7 +759,7 @@ async def file_for_content(
         uploaded_file = files_db.get(content_sha256)
         if uploaded_file:
             try:
-                upload: File = client.files.get(uploaded_file)
+                upload: File = client.files.get(name=uploaded_file)
                 if upload.state.name == "ACTIVE":
                     trace(f"Using uploaded file: {uploaded_file}")
                     return upload
@@ -752,10 +771,12 @@ async def file_for_content(
                 trace(f"Error attempting to access uploaded file: {ex}")
                 files_db.delete(content_sha256)
         # do the upload (and record it)
-        upload = client.files.upload(BytesIO(content_bytes), mime_type=mime_type)
+        upload = client.files.upload(
+            file=BytesIO(content_bytes), config=dict(mime_type=mime_type)
+        )
         while upload.state.name == "PROCESSING":
             await asyncio.sleep(3)
-            upload = client.files.get(upload.name)
+            upload = client.files.get(name=upload.name)
         if upload.state.name == "FAILED":
             trace(f"Failed to upload file '{upload.name}: {upload.error}")
             raise ValueError(f"Google file upload failed: {upload.error}")

inspect_ai/model/_providers/groq.py

@@ -1,5 +1,6 @@
 import json
 import os
+from copy import copy
 from typing import Any, Dict, Iterable, List, Optional
 
 import httpx
@@ -19,10 +20,15 @@ from groq.types.chat import (
     ChatCompletionToolMessageParam,
     ChatCompletionUserMessageParam,
 )
+from pydantic import JsonValue
 from typing_extensions import override
 
-from inspect_ai._util.constants import DEFAULT_MAX_RETRIES, DEFAULT_MAX_TOKENS
-from inspect_ai._util.content import Content
+from inspect_ai._util.constants import (
+    BASE_64_DATA_REMOVED,
+    DEFAULT_MAX_RETRIES,
+    DEFAULT_MAX_TOKENS,
+)
+from inspect_ai._util.content import Content, ContentReasoning, ContentText
 from inspect_ai._util.images import file_as_data_uri
 from inspect_ai._util.url import is_http_url
 from inspect_ai.tool import ToolCall, ToolChoice, ToolFunction, ToolInfo
@@ -48,6 +54,7 @@ from .util import (
     environment_prerequisite_error,
     model_base_url,
 )
+from .util.tracker import HttpxTimeTracker
 
 GROQ_API_KEY = "GROQ_API_KEY"
 
@@ -87,6 +94,9 @@ class GroqAPI(ModelAPI):
             http_client=httpx.AsyncClient(limits=httpx.Limits(max_connections=None)),
         )
 
+        # create time tracker
+        self._time_tracker = HttpxTimeTracker(self.client._client)
+
     @override
     async def close(self) -> None:
         await self.client.close()
@@ -98,6 +108,21 @@ class GroqAPI(ModelAPI):
         tool_choice: ToolChoice,
         config: GenerateConfig,
     ) -> tuple[ModelOutput, ModelCall]:
+        # allocate request_id (so we can see it from ModelCall)
+        request_id = self._time_tracker.start_request()
+
+        # setup request and response for ModelCall
+        request: dict[str, Any] = {}
+        response: dict[str, Any] = {}
+
+        def model_call() -> ModelCall:
+            return ModelCall.create(
+                request=request,
+                response=response,
+                filter=model_call_filter,
+                time=self._time_tracker.end_request(request_id),
+            )
+
         messages = await as_groq_chat_messages(input)
 
         params = self.completion_params(config)
@@ -109,51 +134,52 @@ class GroqAPI(ModelAPI):
             if config.parallel_tool_calls is not None:
                 params["parallel_tool_calls"] = config.parallel_tool_calls
 
-        response: ChatCompletion = await self.client.chat.completions.create(
+        request = dict(
             messages=messages,
             model=self.model_name,
+            extra_headers={HttpxTimeTracker.REQUEST_ID_HEADER: request_id},
             **params,
         )
 
+        completion: ChatCompletion = await self.client.chat.completions.create(
+            **request,
+        )
+
+        response = completion.model_dump()
+
         # extract metadata
         metadata: dict[str, Any] = {
-            "id": response.id,
-            "system_fingerprint": response.system_fingerprint,
-            "created": response.created,
+            "id": completion.id,
+            "system_fingerprint": completion.system_fingerprint,
+            "created": completion.created,
         }
-        if response.usage:
+        if completion.usage:
             metadata = metadata | {
-                "queue_time": response.usage.queue_time,
-                "prompt_time": response.usage.prompt_time,
-                "completion_time": response.usage.completion_time,
-                "total_time": response.usage.total_time,
+                "queue_time": completion.usage.queue_time,
+                "prompt_time": completion.usage.prompt_time,
+                "completion_time": completion.usage.completion_time,
+                "total_time": completion.usage.total_time,
             }
 
         # extract output
-        choices = self._chat_choices_from_response(response, tools)
+        choices = self._chat_choices_from_response(completion, tools)
         output = ModelOutput(
-            model=response.model,
+            model=completion.model,
             choices=choices,
             usage=(
                 ModelUsage(
-                    input_tokens=response.usage.prompt_tokens,
-                    output_tokens=response.usage.completion_tokens,
-                    total_tokens=response.usage.total_tokens,
+                    input_tokens=completion.usage.prompt_tokens,
+                    output_tokens=completion.usage.completion_tokens,
+                    total_tokens=completion.usage.total_tokens,
                 )
-                if response.usage
+                if completion.usage
                 else None
             ),
             metadata=metadata,
         )
 
-        # record call
-        call = ModelCall.create(
-            request=dict(messages=messages, model=self.model_name, **params),
-            response=response.model_dump(),
-        )
-
         # return
-        return output, call
+        return output, model_call()
 
     def completion_params(self, config: GenerateConfig) -> Dict[str, Any]:
         params: dict[str, Any] = {}
@@ -300,10 +326,23 @@ def chat_tool_calls(message: Any, tools: list[ToolInfo]) -> Optional[List[ToolCa
 def chat_message_assistant(message: Any, tools: list[ToolInfo]) -> ChatMessageAssistant:
     reasoning = getattr(message, "reasoning", None)
     if reasoning is not None:
-        reasoning = str(reasoning)
+        content: str | list[Content] = [
+            ContentReasoning(reasoning=str(reasoning)),
+            ContentText(text=message.content or ""),
+        ]
+    else:
+        content = message.content or ""
+
     return ChatMessageAssistant(
-        content=message.content or "",
+        content=content,
         source="generate",
         tool_calls=chat_tool_calls(message, tools),
-        reasoning=reasoning,
     )
+
+
+def model_call_filter(key: JsonValue | None, value: JsonValue) -> JsonValue:
+    # remove base64 encoded images
+    if key == "image_url" and isinstance(value, dict):
+        value = copy(value)
+        value.update(url=BASE_64_DATA_REMOVED)
+    return value