inspect-ai 0.3.56__py3-none-any.whl → 0.3.58__py3-none-any.whl

inspect_ai/model/_call_tools.py

@@ -1,15 +1,20 @@
 import asyncio
 import inspect
+import types
 from dataclasses import is_dataclass
 from logging import getLogger
 from textwrap import dedent
+from types import UnionType
 from typing import (
     Any,
     Callable,
     Dict,
     List,
     NamedTuple,
+    Optional,
+    Tuple,
     Type,
+    Union,
     get_args,
     get_origin,
     get_type_hints,
@@ -19,16 +24,19 @@ from typing import (
 from jsonschema import Draft7Validator
 from pydantic import BaseModel
 
-from inspect_ai._util.content import Content, ContentImage, ContentText
+from inspect_ai._util.content import (
+    Content,
+    ContentAudio,
+    ContentImage,
+    ContentText,
+    ContentVideo,
+)
 from inspect_ai._util.format import format_function_call
 from inspect_ai._util.text import truncate_string_to_bytes
 from inspect_ai._util.trace import trace_action
-from inspect_ai.model._trace import trace_tool_mesage
+from inspect_ai.model._conversation import conversation_tool_mesage
 from inspect_ai.tool import Tool, ToolCall, ToolError, ToolInfo
-from inspect_ai.tool._tool import (
-    ToolApprovalError,
-    ToolParsingError,
-)
+from inspect_ai.tool._tool import ToolApprovalError, ToolParsingError
 from inspect_ai.tool._tool_call import ToolCallContent, ToolCallError
 from inspect_ai.tool._tool_def import ToolDef, tool_defs
 from inspect_ai.tool._tool_info import parse_docstring
@@ -118,10 +126,14 @@ async def call_tools(
             # massage result, leave list[Content] alone, convert all other
             # types to string as that is what the model APIs accept
             truncated: tuple[int, int] | None = None
-            if isinstance(result, ContentText | ContentImage):
+            if isinstance(
+                result, ContentText | ContentImage | ContentAudio | ContentVideo
+            ):
                 content: str | list[Content] = [result]
             elif isinstance(result, list) and (
-                isinstance(result[0], ContentText | ContentImage)
+                isinstance(
+                    result[0], ContentText | ContentImage | ContentAudio | ContentVideo
+                )
             ):
                 content = result
             else:
@@ -161,6 +173,9 @@ async def call_tools(
         # call tools
         tool_messages: list[ChatMessageTool] = []
         for call in message.tool_calls:
+            # create the task
+            task = asyncio.create_task(call_tool_task(call))
+
             # create pending tool event and add it to the transcript
             event = ToolEvent(
                 id=call.id,
@@ -169,15 +184,44 @@ async def call_tools(
                 view=call.view,
                 pending=True,
             )
+            event.set_task(task)
             transcript()._event(event)
 
-            # execute the tool call
-            task = asyncio.create_task(call_tool_task(call))
-            tool_message, result_event = await task
+            # execute the tool call. if the operator cancelled the
+            # tool call then synthesize the appropriate message/event
+            try:
+                tool_message, result_event = await task
+            except asyncio.CancelledError:
+                if event.cancelled:
+                    tool_message = ChatMessageTool(
+                        content="",
+                        function=call.function,
+                        tool_call_id=call.id,
+                        error=ToolCallError(
+                            "timeout", "Command timed out before completing."
+                        ),
+                    )
+                    result_event = ToolEvent(
+                        id=call.id,
+                        function=call.function,
+                        arguments=call.arguments,
+                        result=tool_message.content,
+                        truncated=None,
+                        view=call.view,
+                        error=tool_message.error,
+                        events=[],
+                    )
+                    transcript().info(
+                        f"Tool call '{call.function}' was cancelled by operator."
+                    )
+                else:
+                    raise
+
+            # update return messages
             tool_messages.append(tool_message)
 
-            # trace if we are tracing
-            trace_tool_mesage(tool_message)
+            # print conversation if display is conversation
+            conversation_tool_mesage(tool_message)
 
             # update the event with the results
             event.set_result(
@@ -268,6 +312,16 @@ def disable_parallel_tools(
     return False
 
 
+def type_hint_includes_none(type_hint: Type[Any] | None) -> bool:
+    origin = get_origin(type_hint)
+
+    if origin in {Union, UnionType}:
+        return type(None) in get_args(type_hint)
+    elif origin is Optional:
+        return True
+    return False
+
+
 def tool_params(input: dict[str, Any], func: Callable[..., Any]) -> dict[str, Any]:
     # parse function typeinfo
     signature = inspect.signature(func)
@@ -296,7 +350,7 @@ def tool_params(input: dict[str, Any], func: Callable[..., Any]) -> dict[str, An
         # yield parameter (fail if not passed and there is no default)
         if param_name in input:
             params[param_name] = tool_param(type_hint, input.get(param_name))
-        elif param.default is not None:
+        elif param.default is not None or type_hint_includes_none(type_hint):
             params[param_name] = param.default
         else:
             raise ToolParsingError(
@@ -339,11 +393,21 @@ def tool_param(type_hint: Type[Any], input: Any) -> Any:
             return [tool_param(args[0], x) for x in input]
         else:
             return input
+    elif origin is tuple or origin is Tuple:
+        if args:
+            return tuple([tool_param(args[0], x) for x in input])
+        else:
+            return tuple(input)
     elif origin is dict or origin is Dict:
         if args and len(args) > 1:
             return {k: tool_param(args[1], v) for k, v in input}
         else:
             return input
+    elif origin is Union or origin is types.UnionType:
+        if args[1] is type(None):
+            return tool_param(args[0], input)
+        else:
+            return input
     else:
         return input
 
@@ -389,12 +453,13 @@ def truncate_tool_output(
     # truncate if required
     truncated = truncate_string_to_bytes(output, active_max_output)
     if truncated:
-        truncated_output = dedent(f"""
+        truncated_output = dedent("""
             The output of your call to {tool_name} was too long to be displayed.
             Here is a truncated version:
             <START_TOOL_OUTPUT>
-            {truncated.output}
-            <END_TOOL_OUTPUT>""")
+            {truncated_output}
+            <END_TOOL_OUTPUT>
+            """).format(tool_name=tool_name, truncated_output=truncated.output)
         return TruncatedToolOutput(
             truncated_output, truncated.original_bytes, active_max_output
         )

inspect_ai/model/_chat_message.py

@@ -59,10 +59,8 @@ class ChatMessageBase(BaseModel):
         if isinstance(self.content, str):
             self.content = text
         else:
-            all_images = [
-                content for content in self.content if content.type == "image"
-            ]
-            self.content = [ContentText(text=text)] + all_images
+            all_other = [content for content in self.content if content.type != "text"]
+            self.content = [ContentText(text=text)] + all_other
 
 
 class ChatMessageSystem(ChatMessageBase):

inspect_ai/model/{_trace.py → _conversation.py}

@@ -3,7 +3,8 @@ from rich.text import Text
 
 from inspect_ai._util.rich import lines_display
 from inspect_ai._util.transcript import transcript_markdown
-from inspect_ai.util._trace import trace_enabled, trace_panel
+from inspect_ai.util._conversation import conversation_panel
+from inspect_ai.util._display import display_type
 
 from ._chat_message import ChatMessage, ChatMessageAssistant, ChatMessageTool
 from ._render import messages_preceding_assistant, render_tool_calls
@@ -11,25 +12,25 @@ from ._render import messages_preceding_assistant, render_tool_calls
 MESSAGE_TITLE = "Message"
 
 
-def trace_tool_mesage(message: ChatMessageTool) -> None:
-    if trace_enabled():
+def conversation_tool_mesage(message: ChatMessageTool) -> None:
+    if display_type() == "conversation":
         # truncate output to 100 lines
         output = message.error.message if message.error else message.text.strip()
         content = lines_display(output, 100)
 
-        trace_panel(
+        conversation_panel(
             title=f"Tool Output: {message.function}",
             content=content,
         )
 
 
-def trace_assistant_message(
+def conversation_assistant_message(
     input: list[ChatMessage], message: ChatMessageAssistant
 ) -> None:
-    if trace_enabled():
+    if display_type() == "conversation":
         # print precding messages that aren't tool or assistant
         for m in messages_preceding_assistant(input):
-            trace_panel(
+            conversation_panel(
                 title=m.role.capitalize(),
                 content=transcript_markdown(m.text, escape=True),
             )
@@ -45,4 +46,4 @@ def trace_assistant_message(
             content.extend(render_tool_calls(message.tool_calls))
 
         # print the assistant message
-        trace_panel(title="Assistant", content=content)
+        conversation_panel(title="Assistant", content=content)

inspect_ai/model/_model.py

@@ -43,6 +43,7 @@ from ._chat_message import (
     ChatMessageTool,
     ChatMessageUser,
 )
+from ._conversation import conversation_assistant_message
 from ._generate_config import (
     GenerateConfig,
     active_generate_config,
@@ -50,7 +51,6 @@ from ._generate_config import (
 )
 from ._model_call import ModelCall
 from ._model_output import ModelOutput, ModelUsage
-from ._trace import trace_assistant_message
 
 logger = logging.getLogger(__name__)
 
@@ -487,7 +487,7 @@ class Model:
             updated_output: ModelOutput, updated_call: ModelCall | None
         ) -> None:
             # trace
-            trace_assistant_message(input, updated_output.choices[0].message)
+            conversation_assistant_message(input, updated_output.choices[0].message)
 
             # update event
             event.output = updated_output

inspect_ai/model/_providers/anthropic.py

@@ -28,11 +28,11 @@ from pydantic import JsonValue
 from typing_extensions import override
 
 from inspect_ai._util.constants import BASE_64_DATA_REMOVED, DEFAULT_MAX_RETRIES
-from inspect_ai._util.content import Content, ContentText
+from inspect_ai._util.content import Content, ContentImage, ContentText
 from inspect_ai._util.error import exception_message
-from inspect_ai._util.images import image_as_data_uri
+from inspect_ai._util.images import file_as_data_uri
 from inspect_ai._util.logger import warn_once
-from inspect_ai._util.url import data_uri_mime_type, data_uri_to_base64, is_data_uri
+from inspect_ai._util.url import data_uri_mime_type, data_uri_to_base64
 from inspect_ai.tool import ToolCall, ToolChoice, ToolFunction, ToolInfo
 
 from .._chat_message import (
@@ -584,11 +584,9 @@ async def message_param_content(
 ) -> TextBlockParam | ImageBlockParam:
     if isinstance(content, ContentText):
         return TextBlockParam(type="text", text=content.text or NO_CONTENT)
-    else:
+    elif isinstance(content, ContentImage):
         # resolve to url
-        image = content.image
-        if not is_data_uri(image):
-            image = await image_as_data_uri(image)
+        image = await file_as_data_uri(content.image)
 
         # resolve mime type and base64 content
         media_type = data_uri_mime_type(image) or "image/png"
@@ -601,6 +599,10 @@ async def message_param_content(
             type="image",
             source=dict(type="base64", media_type=cast(Any, media_type), data=image),
         )
+    else:
+        raise RuntimeError(
+            "Anthropic models do not currently support audio or video inputs."
+        )
 
 
 def model_call_filter(key: JsonValue | None, value: JsonValue) -> JsonValue:

inspect_ai/model/_providers/azureai.py

@@ -31,8 +31,8 @@ from azure.core.exceptions import AzureError, HttpResponseError
 from typing_extensions import override
 
 from inspect_ai._util.constants import DEFAULT_MAX_TOKENS
-from inspect_ai._util.content import Content, ContentText
-from inspect_ai._util.images import image_as_data_uri
+from inspect_ai._util.content import Content, ContentImage, ContentText
+from inspect_ai._util.images import file_as_data_uri
 from inspect_ai.tool import ToolChoice, ToolInfo
 from inspect_ai.tool._tool_call import ToolCall
 from inspect_ai.tool._tool_choice import ToolFunction
@@ -312,12 +312,14 @@ async def chat_request_message(
 async def chat_content_item(content: Content) -> ContentItem:
     if isinstance(content, ContentText):
         return TextContentItem(text=content.text)
-    else:
+    elif isinstance(content, ContentImage):
         return ImageContentItem(
             image_url=ImageUrl(
-                url=await image_as_data_uri(content.image), detail=content.detail
+                url=await file_as_data_uri(content.image), detail=content.detail
             )
         )
+    else:
+        raise RuntimeError("Azure AI models do not support audio or video inputs.")
 
 
 def chat_tool_call(tool_call: ToolCall) -> ChatCompletionsToolCall:

inspect_ai/model/_providers/bedrock.py

@@ -11,7 +11,7 @@ from inspect_ai._util.constants import (
 )
 from inspect_ai._util.content import Content, ContentImage, ContentText
 from inspect_ai._util.error import pip_dependency_error
-from inspect_ai._util.images import image_as_data
+from inspect_ai._util.images import file_as_data
 from inspect_ai._util.version import verify_required_version
 from inspect_ai.tool import ToolChoice, ToolInfo
 from inspect_ai.tool._tool_call import ToolCall
@@ -430,7 +430,9 @@ def model_output_from_response(
             content.append(ContentText(type="text", text=c.text))
         elif c.image is not None:
             base64_image = base64.b64encode(c.image.source.bytes).decode("utf-8")
-            content.append(ContentImage(image=base64_image))
+            content.append(
+                ContentImage(image=f"data:image/{c.image.format};base64,{base64_image}")
+            )
         elif c.toolUse is not None:
             tool_calls.append(
                 ToolCall(
@@ -565,7 +567,7 @@ async def converse_chat_message(
                 if c.type == "text":
                     tool_result_content.append(ConverseToolResultContent(text=c.text))
                 elif c.type == "image":
-                    image_data, image_type = await image_as_data(c.image)
+                    image_data, image_type = await file_as_data(c.image)
                     tool_result_content.append(
                         ConverseToolResultContent(
                             image=ConverseImage(
@@ -604,7 +606,7 @@ async def converse_contents(
         result: list[ConverseMessageContent] = []
         for c in content:
             if c.type == "image":
-                image_data, image_type = await image_as_data(c.image)
+                image_data, image_type = await file_as_data(c.image)
                 result.append(
                     ConverseMessageContent(
                         image=ConverseImage(

inspect_ai/model/_providers/google.py

@@ -1,12 +1,17 @@
+import asyncio
 import functools
+import hashlib
 import json
 from copy import copy
+from io import BytesIO
+from logging import getLogger
 from typing import Any, cast
 
 import proto  # type: ignore
 from google.ai.generativelanguage import (
     Blob,
     Candidate,
+    File,
     FunctionCall,
     FunctionCallingConfig,
     FunctionDeclaration,
@@ -28,6 +33,8 @@ from google.generativeai import (  # type: ignore
     GenerationConfig,
     GenerativeModel,
     configure,
+    get_file,
+    upload_file,
 )
 from google.generativeai.types import (  # type: ignore
     AsyncGenerateContentResponse,
@@ -45,8 +52,16 @@ from pydantic import JsonValue
 from typing_extensions import override
 
 from inspect_ai._util.constants import BASE_64_DATA_REMOVED
-from inspect_ai._util.content import Content, ContentImage, ContentText
-from inspect_ai._util.images import image_as_data
+from inspect_ai._util.content import (
+    Content,
+    ContentAudio,
+    ContentImage,
+    ContentText,
+    ContentVideo,
+)
+from inspect_ai._util.images import file_as_data
+from inspect_ai._util.kvstore import inspect_kvstore
+from inspect_ai._util.trace import trace_message
 from inspect_ai.tool import ToolCall, ToolChoice, ToolInfo, ToolParam, ToolParams
 
 from .._chat_message import (
@@ -70,6 +85,8 @@ from .._model_output import (
 )
 from .util import model_base_url
 
+logger = getLogger(__name__)
+
 SAFETY_SETTINGS = "safety_settings"
 
 DEFAULT_SAFETY_SETTINGS: SafetySettingDict = {
@@ -194,7 +211,9 @@ class GoogleAPI(ModelAPI):
                 model=self.model_name, content=ex.message, stop_reason="model_length"
             )
         else:
-            raise ex
+            return ModelOutput.from_content(
+                model=self.model_name, content=ex.message, stop_reason="unknown"
+            )
 
     @override
     def is_rate_limit(self, ex: BaseException) -> bool:
@@ -362,19 +381,23 @@ def dict_to_struct(x: dict[str, Any]) -> Struct:
     return struct
 
 
-async def content_part(content: Content | str) -> PartDict:
+async def content_part(content: Content | str) -> PartType:
     if isinstance(content, str):
         return PartDict(text=content or NO_CONTENT)
     elif isinstance(content, ContentText):
         return PartDict(text=content.text or NO_CONTENT)
     else:
-        return PartDict(inline_data=await chat_content_image_to_blob(content))
+        return await chat_content_to_part(content)
 
 
-async def chat_content_image_to_blob(image: ContentImage) -> Blob:
-    image_url = image.image
-    image_bytes, mime_type = await image_as_data(image_url)
-    return Blob(mime_type=mime_type, data=image_bytes)
+async def chat_content_to_part(
+    content: ContentImage | ContentAudio | ContentVideo,
+) -> PartType:
+    if isinstance(content, ContentImage):
+        content_bytes, mime_type = await file_as_data(content.image)
+        return Blob(mime_type=mime_type, data=content_bytes)
+    else:
+        return await file_for_content(content)
 
 
 def prepend_system_messages(
@@ -408,25 +431,34 @@ def chat_tools(tools: list[ToolInfo]) -> list[Tool]:
 # https://ai.google.dev/gemini-api/tutorials/extract_structured_data#define_the_schema
 
 
-def schema_from_param(param: ToolParam | ToolParams) -> Schema:
+def schema_from_param(param: ToolParam | ToolParams, nullable: bool = False) -> Schema:
     if isinstance(param, ToolParams):
         param = ToolParam(
             type=param.type, properties=param.properties, required=param.required
         )
 
     if param.type == "number":
-        return Schema(type=Type.NUMBER, description=param.description)
+        return Schema(
+            type=Type.NUMBER, description=param.description, nullable=nullable
+        )
     elif param.type == "integer":
-        return Schema(type=Type.INTEGER, description=param.description)
+        return Schema(
+            type=Type.INTEGER, description=param.description, nullable=nullable
+        )
     elif param.type == "boolean":
-        return Schema(type=Type.BOOLEAN, description=param.description)
+        return Schema(
+            type=Type.BOOLEAN, description=param.description, nullable=nullable
+        )
     elif param.type == "string":
-        return Schema(type=Type.STRING, description=param.description)
+        return Schema(
+            type=Type.STRING, description=param.description, nullable=nullable
+        )
     elif param.type == "array":
         return Schema(
             type=Type.ARRAY,
             description=param.description,
             items=schema_from_param(param.items) if param.items else None,
+            nullable=nullable,
         )
     elif param.type == "object":
         return Schema(
@@ -436,7 +468,14 @@ def schema_from_param(param: ToolParam | ToolParams) -> Schema:
             if param.properties is not None
             else None,
             required=param.required,
+            nullable=nullable,
         )
+    # convert unions to optional params if the second type is 'null'
+    elif param.anyOf:
+        if len(param.anyOf) == 2 and param.anyOf[1].type == "null":
+            return schema_from_param(param.anyOf[0], nullable=True)
+        else:
+            return Schema(type=Type.TYPE_UNSPECIFIED)
     else:
         return Schema(type=Type.TYPE_UNSPECIFIED)
 
@@ -612,3 +651,53 @@ def str_to_harm_block_threshold(threshold: str) -> HarmBlockThreshold:
         return HarmBlockThreshold.BLOCK_NONE
     else:
         raise ValueError(f"Unknown HarmBlockThreshold: {threshold}")
+
+
+async def file_for_content(content: ContentAudio | ContentVideo) -> File:
+    # helper to write trace messages
+    def trace(message: str) -> None:
+        trace_message(logger, "Google Files", message)
+
+    # get the file bytes and compute sha256 hash
+    if isinstance(content, ContentAudio):
+        file = content.audio
+    else:
+        file = content.video
+    content_bytes, mime_type = await file_as_data(file)
+    content_sha256 = hashlib.sha256(content_bytes).hexdigest()
+
+    # we cache uploads for re-use, open the db where we track that
+    # (track up to 1 million previous uploads)
+    with inspect_kvstore("google_files", 1000000) as files_db:
+        # can we serve from existing uploads?
+        uploaded_file = files_db.get(content_sha256)
+        if uploaded_file:
+            try:
+                upload = cast(File, get_file(uploaded_file))
+                if upload.state.name == "ACTIVE":
+                    trace(f"Using uploaded file: {uploaded_file}")
+                    return upload
+                else:
+                    trace(
+                        f"Not using uploaded file '{uploaded_file} (state was {upload.state})"
+                    )
+            except Exception as ex:
+                trace(f"Error attempting to access uploaded file: {ex}")
+                files_db.delete(content_sha256)
+
+        # do the upload (and record it)
+        upload = upload_file(BytesIO(content_bytes), mime_type=mime_type)
+        while upload.state.name == "PROCESSING":
+            await asyncio.sleep(3)
+            upload = get_file(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}")
+
+        # trace and record it
+        trace(f"Uploaded file: {upload.name}")
+        files_db.put(content_sha256, upload.name)
+
+        # return the file
+        return upload

inspect_ai/model/_providers/groq.py

@@ -23,8 +23,8 @@ 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.images import image_as_data_uri
-from inspect_ai._util.url import is_data_uri, is_http_url
+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
 
 from .._chat_message import (
@@ -248,18 +248,20 @@ async def as_chat_completion_part(
 ) -> ChatCompletionContentPartParam:
     if content.type == "text":
         return ChatCompletionContentPartTextParam(type="text", text=content.text)
-    else:
+    elif content.type == "image":
         # API takes URL or base64 encoded file. If it's a remote file or data URL leave it alone, otherwise encode it
         image_url = content.image
         detail = content.detail
 
-        if not is_http_url(image_url) and not is_data_uri(image_url):
-            image_url = await image_as_data_uri(image_url)
+        if not is_http_url(image_url):
+            image_url = await file_as_data_uri(image_url)
 
         return ChatCompletionContentPartImageParam(
             type="image_url",
             image_url=dict(url=image_url, detail=detail),
         )
+    else:
+        raise RuntimeError("Groq models do not support audio or video inputs.")
 
 
 def chat_tools(tools: List[ToolInfo]) -> List[Dict[str, Any]]:

inspect_ai/model/_providers/hf.py

@@ -239,12 +239,17 @@ class HuggingFaceAPI(ModelAPI):
                 hf_messages = inspect_tools_to_string(hf_messages)
 
         # apply chat template
-        chat = self.tokenizer.apply_chat_template(
-            hf_messages,
-            add_generation_prompt=True,
-            tokenize=False,
-            tools=tools_list if len(tools_list) > 0 else None,
-        )
+        if self.tokenizer.chat_template is not None:
+            chat = self.tokenizer.apply_chat_template(
+                hf_messages,
+                add_generation_prompt=True,
+                tokenize=False,
+                tools=tools_list if len(tools_list) > 0 else None,
+            )
+        else:
+            chat = ""
+            for message in hf_messages:
+                chat += f"{message.role}: {message.content}\n"
         # return
         return cast(str, chat)
 

inspect_ai/model/_providers/mistral.py

@@ -42,8 +42,7 @@ from inspect_ai._util.constants import (
     DEFAULT_TIMEOUT,
 )
 from inspect_ai._util.content import Content, ContentImage, ContentText
-from inspect_ai._util.images import image_as_data_uri
-from inspect_ai._util.url import is_data_uri
+from inspect_ai._util.images import file_as_data_uri
 from inspect_ai.tool import ToolCall, ToolChoice, ToolFunction, ToolInfo
 
 from .._chat_message import (
@@ -351,16 +350,14 @@ def mistral_system_message_content(
 async def mistral_content_chunk(content: Content) -> ContentChunk:
     if isinstance(content, ContentText):
         return TextChunk(text=content.text or NO_CONTENT)
-    else:
+    elif isinstance(content, ContentImage):
         # resolve image to url
-        image_url = content.image
-        if not is_data_uri(image_url):
-            image_url = await image_as_data_uri(image_url)
+        image_url = await file_as_data_uri(content.image)
 
         # return chunk
-        return ImageURLChunk(
-            image_url=ImageURL(url=content.image, detail=content.detail)
-        )
+        return ImageURLChunk(image_url=ImageURL(url=image_url, detail=content.detail))
+    else:
+        raise RuntimeError("Mistral models do not support audio or video inputs.")
 
 
 def mistral_tool_call(tool_call: ToolCall) -> MistralToolCall: