> ## Documentation Index
> Fetch the complete documentation index at: https://www.adaline.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# MessageContent

# MessageContent

Multi-modal content types for messages and variables in the Python SDK.

## Overview

Content types support text, images, PDFs, tool calls/responses, reasoning, errors, and search results. The `MessageContent` class is a oneOf union wrapper — the actual content is accessed via the `actual_instance` property.

***

## MessageContent (Union Type)

Polymorphic content type supporting multiple modalities. Uses `actual_instance` to hold the concrete content variant.

```python theme={null}
from adaline_api.models.message_content import MessageContent
```

The `actual_instance` must be one of:

| Type                  | Modality          | Description                         |
| --------------------- | ----------------- | ----------------------------------- |
| `TextContent`         | `"text"`          | Plain text content                  |
| `ImageContent`        | `"image"`         | Image with detail level             |
| `PdfContent`          | `"pdf"`           | PDF document with file metadata     |
| `ReasoningContent`    | `"reasoning"`     | Chain-of-thought reasoning          |
| `ToolCallContent`     | `"tool-call"`     | Tool/function call request          |
| `ToolResponseContent` | `"tool-response"` | Tool/function execution response    |
| `ErrorContent`        | `"error"`         | Safety and content filtering errors |
| `SearchResultContent` | `"search-result"` | Web search grounding results        |

**Accessing content**:

```python theme={null}
from adaline_api.models.message_content import MessageContent
from adaline_api.models.text_content import TextContent
from adaline_api.models.image_content import ImageContent

content = MessageContent(actual_instance=TextContent(
    modality="text",
    value="Hello!"
))

# Access the underlying content
inner = content.actual_instance  # TextContent instance
print(inner.modality)            # 'text'
print(inner.value)               # 'Hello!'
```

**Type checking**:

```python theme={null}
from adaline_api.models.text_content import TextContent
from adaline_api.models.image_content import ImageContent
from adaline_api.models.tool_call_content import ToolCallContent

def process_content(content: MessageContent):
    instance = content.actual_instance

    if isinstance(instance, TextContent):
        print("Text:", instance.value)
    elif isinstance(instance, ImageContent):
        print("Image, detail:", instance.detail)
    elif isinstance(instance, ToolCallContent):
        print("Tool call:", instance.name)
```

***

## Text Content

### TextContent

See the dedicated [TextContent](/docs/reference/sdk/v2/python/types/TextContent) page for full documentation.

Plain text content for messages.

```python theme={null}
from adaline_api.models.text_content import TextContent
```

#### Fields

<ParamField body="modality" type="str" required>
  Must be `"text"`.
</ParamField>

<ParamField body="value" type="str" required>
  The text content string.
</ParamField>

#### Example

```python theme={null}
from adaline_api.models.text_content import TextContent
from adaline_api.models.message_content import MessageContent

text = TextContent(modality="text", value="Hello, how are you?")

content = MessageContent(actual_instance=text)
```

**JSON**:

```json theme={null}
{
  "modality": "text",
  "value": "Hello, how are you?"
}
```

***

## Image Content

### ImageContent

See the dedicated [ImageContent](/docs/reference/sdk/v2/python/types/ImageContent) page for full documentation.

Image content with detail level specification.

```python theme={null}
from adaline_api.models.image_content import ImageContent
```

#### Fields

<ParamField body="modality" type="str" required>
  Must be `"image"`.
</ParamField>

<ParamField body="detail" type="str" required>
  Detail level. One of: `"low"`, `"medium"`, `"high"`, `"auto"`.
</ParamField>

<ParamField body="value" type="ImageContentValue" required>
  Image data — either a URL or base64-encoded content. See [ImageContentValue](#imagecontentvalue).
</ParamField>

### ImageContentValue

Union of URL or base64 image content. Use `from_dict()` to construct.

```python theme={null}
from adaline_api.models.image_content_value import ImageContentValue
```

#### Example

```python theme={null}
from adaline_api.models.image_content import ImageContent
from adaline_api.models.image_content_value import ImageContentValue
from adaline_api.models.message_content import MessageContent

# URL image
image = ImageContent(
    modality="image",
    detail="high",
    value=ImageContentValue.from_dict({
        "type": "url",
        "url": "https://example.com/chart.png"
    })
)

content = MessageContent(actual_instance=image)

# Base64 image
base64_image = ImageContent(
    modality="image",
    detail="auto",
    value=ImageContentValue.from_dict({
        "type": "base64",
        "base64": "iVBORw0KGgoAAAANSUhEUgA...",
        "mediaType": "jpeg"
    })
)
```

**JSON**:

```json theme={null}
{
  "modality": "image",
  "detail": "high",
  "value": {
    "type": "url",
    "url": "https://example.com/image.jpg"
  }
}
```

***

## PDF Content

### PdfContent

See the dedicated [PdfContent](/docs/reference/sdk/v2/python/types/PdfContent) page for full documentation.

PDF document content with file metadata.

```python theme={null}
from adaline_api.models.pdf_content import PdfContent
```

#### Fields

<ParamField body="modality" type="str" required>
  Must be `"pdf"`.
</ParamField>

<ParamField body="value" type="PdfContentValue" required>
  PDF data — either a URL or base64-encoded content.
</ParamField>

<ParamField body="file" type="PdfContentFile" required>
  File metadata with `name`, `id`, and optional `size`.
</ParamField>

#### Example

```python theme={null}
from adaline_api.models.pdf_content import PdfContent
from adaline_api.models.pdf_content_value import PdfContentValue
from adaline_api.models.pdf_content_file import PdfContentFile
from adaline_api.models.message_content import MessageContent

pdf = PdfContent(
    modality="pdf",
    value=PdfContentValue.from_dict({
        "type": "url",
        "url": "https://example.com/report.pdf"
    }),
    file=PdfContentFile(
        name="Q4_Report.pdf",
        id="file_abc123",
        size=1024000
    )
)

content = MessageContent(actual_instance=pdf)
```

**JSON**:

```json theme={null}
{
  "modality": "pdf",
  "value": {
    "type": "url",
    "url": "https://example.com/report.pdf"
  },
  "file": {
    "name": "report.pdf",
    "id": "file_123",
    "size": 1024000
  }
}
```

***

## Tool Content

### ToolCallContent

See the dedicated [ToolCallContent](/docs/reference/sdk/v2/python/types/ToolCallContent) page for full documentation.

Tool/function call request from LLM.

```python theme={null}
from adaline_api.models.tool_call_content import ToolCallContent
```

#### Fields

<ParamField body="modality" type="str" required>
  Must be `"tool-call"`.
</ParamField>

<ParamField body="index" type="int" required>
  Zero-based index of the tool call. Minimum: 0.
</ParamField>

<ParamField body="id" type="str" required>
  Unique identifier for this tool call.
</ParamField>

<ParamField body="name" type="str" required>
  Name of the function to call.
</ParamField>

<ParamField body="arguments" type="str" required>
  JSON-encoded string of function arguments.
</ParamField>

<ParamField body="server_name" type="str | None" optional>
  Optional MCP server name. Aliased as `serverName` in JSON.
</ParamField>

#### Example

```python theme={null}
import json
from adaline_api.models.tool_call_content import ToolCallContent
from adaline_api.models.message_content import MessageContent

tool_call = ToolCallContent(
    modality="tool-call",
    index=0,
    id="call_abc123",
    name="get_weather",
    arguments=json.dumps({
        "city": "San Francisco",
        "units": "fahrenheit"
    }),
    server_name="weather-api"
)

content = MessageContent(actual_instance=tool_call)
```

**JSON**:

```json theme={null}
{
  "modality": "tool-call",
  "index": 0,
  "id": "call_abc123",
  "name": "get_weather",
  "arguments": "{\"city\":\"San Francisco\"}"
}
```

***

### ToolResponseContent

See the dedicated [ToolResponseContent](/docs/reference/sdk/v2/python/types/ToolResponseContent) page for full documentation.

Tool/function execution response.

```python theme={null}
from adaline_api.models.tool_response_content import ToolResponseContent
```

#### Fields

<ParamField body="modality" type="str" required>
  Must be `"tool-response"`.
</ParamField>

<ParamField body="index" type="int" required>
  Zero-based index matching the tool call. Minimum: 0.
</ParamField>

<ParamField body="id" type="str" required>
  Identifier matching the tool call `id`.
</ParamField>

<ParamField body="name" type="str" required>
  Name of the function that was called.
</ParamField>

<ParamField body="data" type="str" required>
  JSON-encoded string of the function result.
</ParamField>

<ParamField body="api_response" type="ToolResponseContentApiResponse | None" optional>
  Optional API response metadata with `status_code`. Aliased as `apiResponse` in JSON.
</ParamField>

#### Example

```python theme={null}
import json
from adaline_api.models.tool_response_content import ToolResponseContent
from adaline_api.models.message_content import MessageContent

tool_response = ToolResponseContent(
    modality="tool-response",
    index=0,
    id="call_abc123",
    name="get_weather",
    data=json.dumps({
        "temperature": 72,
        "conditions": "sunny",
        "humidity": 65
    })
)

content = MessageContent(actual_instance=tool_response)
```

**JSON**:

```json theme={null}
{
  "modality": "tool-response",
  "index": 0,
  "id": "call_abc123",
  "name": "get_weather",
  "data": "{\"temperature\":72,\"conditions\":\"sunny\"}"
}
```

***

## Reasoning Content

### ReasoningContent

See the dedicated [ReasoningContent](/docs/reference/sdk/v2/python/types/ReasoningContent) page for full documentation.

Reasoning content for chain-of-thought responses.

```python theme={null}
from adaline_api.models.reasoning_content import ReasoningContent
```

#### Fields

<ParamField body="modality" type="str" required>
  Must be `"reasoning"`.
</ParamField>

<ParamField body="value" type="ReasoningContentValueUnion" required>
  The reasoning value — either a `thinking` type with content and signature, or a `redacted` type.
</ParamField>

#### Example

```python theme={null}
from adaline_api.models.reasoning_content import ReasoningContent
from adaline_api.models.reasoning_content_value_union import ReasoningContentValueUnion
from adaline_api.models.message_content import MessageContent

reasoning = ReasoningContent(
    modality="reasoning",
    value=ReasoningContentValueUnion.from_dict({
        "type": "thinking",
        "thinking": "Let me analyze this step by step...",
        "signature": "sig_abc123"
    })
)

content = MessageContent(actual_instance=reasoning)
```

***

## Error Content

### ErrorContent

See the dedicated [ErrorContent](/docs/reference/sdk/v2/python/types/ErrorContent) page for full documentation.

Error content type for LLM safety and content filtering errors.

```python theme={null}
from adaline_api.models.error_content import ErrorContent
```

#### Fields

<ParamField body="modality" type="str" required>
  Must be `"error"`.
</ParamField>

<ParamField body="value" type="SafetyErrorContentValue" required>
  Safety error value with `type` and `value` fields.
</ParamField>

#### Example

```python theme={null}
from adaline_api.models.error_content import ErrorContent
from adaline_api.models.safety_error_content_value import SafetyErrorContentValue
from adaline_api.models.message_content import MessageContent

error = ErrorContent(
    modality="error",
    value=SafetyErrorContentValue(
        type="safety",
        value="Content filtered due to safety policy."
    )
)

content = MessageContent(actual_instance=error)
```

***

## Search Result Content

### SearchResultContent

See the dedicated [SearchResultContent](/docs/reference/sdk/v2/python/types/SearchResultContent) page for full documentation.

Search result content for grounding LLM responses with web search data.

```python theme={null}
from adaline_api.models.search_result_content import SearchResultContent
```

#### Fields

<ParamField body="modality" type="str" required>
  Must be `"search-result"`.
</ParamField>

<ParamField body="value" type="SearchResultGoogleContentValue" required>
  Google search result value with `type`, `references`, and `responses`.
</ParamField>

#### Example

```python theme={null}
from adaline_api.models.search_result_content import SearchResultContent
from adaline_api.models.search_result_google_content_value import SearchResultGoogleContentValue
from adaline_api.models.message_content import MessageContent

search_result = SearchResultContent(
    modality="search-result",
    value=SearchResultGoogleContentValue.from_dict({
        "type": "google",
        "references": [{"title": "Example", "url": "https://example.com", "snippet": "..."}],
        "responses": [{"text": "Search grounding result..."}]
    })
)

content = MessageContent(actual_instance=search_result)
```

***

## Complete Examples

### Multi-Modal Message

```python theme={null}
from adaline_api.models.prompt_message import PromptMessage
from adaline_api.models.message_content import MessageContent
from adaline_api.models.text_content import TextContent
from adaline_api.models.image_content import ImageContent
from adaline_api.models.image_content_value import ImageContentValue
from adaline_api.models.pdf_content import PdfContent
from adaline_api.models.pdf_content_value import PdfContentValue
from adaline_api.models.pdf_content_file import PdfContentFile

message = PromptMessage(
    role="user",
    content=[
        MessageContent(actual_instance=TextContent(
            modality="text",
            value="Analyze this image and document"
        )),
        MessageContent(actual_instance=ImageContent(
            modality="image",
            detail="high",
            value=ImageContentValue.from_dict({
                "type": "url",
                "url": "https://example.com/image.jpg"
            })
        )),
        MessageContent(actual_instance=PdfContent(
            modality="pdf",
            value=PdfContentValue.from_dict({
                "type": "url",
                "url": "https://example.com/report.pdf"
            }),
            file=PdfContentFile(name="report.pdf", id="file_123")
        )),
    ]
)
```

### Tool Call Flow

```python theme={null}
import json
from adaline_api.models.prompt_message import PromptMessage
from adaline_api.models.message_content import MessageContent
from adaline_api.models.text_content import TextContent
from adaline_api.models.tool_call_content import ToolCallContent
from adaline_api.models.tool_response_content import ToolResponseContent

# 1. Assistant makes tool call
assistant_with_tool = PromptMessage(
    role="assistant",
    content=[MessageContent(actual_instance=ToolCallContent(
        modality="tool-call",
        index=0,
        id="call_123",
        name="get_weather",
        arguments=json.dumps({"city": "Paris"})
    ))]
)

# 2. Tool responds
tool_result = PromptMessage(
    role="tool",
    content=[MessageContent(actual_instance=ToolResponseContent(
        modality="tool-response",
        index=0,
        id="call_123",
        name="get_weather",
        data=json.dumps({"temp": 24, "conditions": "sunny"})
    ))]
)

# 3. Assistant uses tool result
final_response = PromptMessage(
    role="assistant",
    content=[MessageContent(actual_instance=TextContent(
        modality="text",
        value="The weather in Paris is sunny with a temperature of 24°C."
    ))]
)
```

### Content Filtering

```python theme={null}
from adaline_api.models.text_content import TextContent
from adaline_api.models.image_content import ImageContent
from adaline_api.models.tool_call_content import ToolCallContent

message: PromptMessage = ...

# Get all text content
text_items = [
    c.actual_instance for c in message.content
    if isinstance(c.actual_instance, TextContent)
]

# Get all images
images = [
    c.actual_instance for c in message.content
    if isinstance(c.actual_instance, ImageContent)
]

# Get tool calls
tool_calls = [
    c.actual_instance for c in message.content
    if isinstance(c.actual_instance, ToolCallContent)
]

# Extract text values
text_values = " ".join(t.value for t in text_items)
```