Implementation:Togethercomputer Together python Chat Completion Message Schema

Attribute	Value
Implementation Name	Chat_Completion_Message_Schema
Overview	Pydantic schema types defining the structure of chat completion messages, including roles, text content, multimodal content, and tool calls.
Type	Pattern Doc
Source File	src/together/types/chat_completions.py
Lines	L21-76
Domain	NLP, API_Client, Inference
Repository	togethercomputer/together-python
Last Updated	2026-02-15 16:00 GMT

Code Reference

MessageRole Enum (L21-25)

class MessageRole(str, Enum):
    ASSISTANT = "assistant"
    SYSTEM = "system"
    USER = "user"
    TOOL = "tool"

ChatCompletionMessage (L72-75)

class ChatCompletionMessage(BaseModel):
    role: MessageRole
    content: str | List[ChatCompletionMessageContent] | None = None
    tool_calls: List[ToolCalls] | None = None

ChatCompletionMessageContent (L64-69)

class ChatCompletionMessageContent(BaseModel):
    type: ChatCompletionMessageContentType
    text: str | None = None
    image_url: ChatCompletionMessageContentImageURL | None = None
    video_url: ChatCompletionMessageContentVideoURL | None = None
    audio_url: ChatCompletionMessageContentAudioURL | None = None

ChatCompletionMessageContentType Enum (L45-49)

class ChatCompletionMessageContentType(str, Enum):
    TEXT = "text"
    IMAGE_URL = "image_url"
    VIDEO_URL = "video_url"
    AUDIO_URL = "audio_url"

URL Content Models (L52-61)

class ChatCompletionMessageContentImageURL(BaseModel):
    url: str

class ChatCompletionMessageContentVideoURL(BaseModel):
    url: str

class ChatCompletionMessageContentAudioURL(BaseModel):
    url: str

Tool Call Types (L34-42)

class FunctionCall(BaseModel):
    name: str | None = None
    arguments: str | None = None

class ToolCalls(BaseModel):
    id: str | None = None
    type: str | None = None
    function: FunctionCall | None = None

Import

Users construct messages as List[Dict[str, Any]] -- the SDK handles Pydantic validation internally. For type-checking purposes:

from together.types.chat_completions import (
    MessageRole,
    ChatCompletionMessage,
    ChatCompletionMessageContent,
    ChatCompletionMessageContentType,
    ToolCalls,
    FunctionCall,
)

I/O Contract

Input (Message Dict Structure)

Field	Type	Required	Description
`role`	"user" \| "assistant" \| "tool"	Yes	The role of the message author.
`content`	List[Dict] \| None	No	Text content or multimodal content list. None for tool-call-only assistant messages.
`tool_calls`	None	No	Tool/function calls made by the assistant. Only valid for role `"assistant"`.

Content List Item Structure

Field	Type	Required	Description
`type`	"image_url" \| "video_url" \| "audio_url"	Yes	The type of content part.
`text`	None	No	Text content (when type is "text").
`image_url`	None	No	Image URL object (when type is "image_url").
`video_url`	None	No	Video URL object (when type is "video_url").
`audio_url`	None	No	Audio URL object (when type is "audio_url").

Tool Call Structure

Field	Type	Required	Description
`id`	None	No	Unique identifier for the tool call.
`type`	None	No	Tool type (typically "function").
`function`	None	No	Function name and JSON-encoded arguments string.

Usage Examples

Simple Text Messages

from together import Together

client = Together()

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is the capital of France?"},
]

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
    messages=messages,
)

Multi-Turn Conversation

messages = [
    {"role": "system", "content": "You are a math tutor."},
    {"role": "user", "content": "What is 2 + 2?"},
    {"role": "assistant", "content": "2 + 2 equals 4."},
    {"role": "user", "content": "And what is 4 * 3?"},
]

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
    messages=messages,
)

Multimodal Message with Image

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Describe this image."},
            {
                "type": "image_url",
                "image_url": {"url": "https://example.com/photo.jpg"},
            },
        ],
    },
]

response = client.chat.completions.create(
    model="meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo",
    messages=messages,
)

Tool Call Messages

# Step 1: Send initial request with tool definitions
messages = [
    {"role": "user", "content": "What's the weather in San Francisco?"},
]

# Step 2: Model responds with tool_calls (in the response)
# Append the assistant message with tool_calls to the conversation
messages.append({
    "role": "assistant",
    "content": None,
    "tool_calls": [
        {
            "id": "call_abc123",
            "type": "function",
            "function": {
                "name": "get_weather",
                "arguments": '{"location": "San Francisco"}',
            },
        }
    ],
})

# Step 3: Append tool result
messages.append({
    "role": "tool",
    "content": '{"temperature": 65, "unit": "fahrenheit", "condition": "foggy"}',
})

# Step 4: Get final response with tool context
response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
    messages=messages,
)

Key Implementation Details

Messages are passed to the API as List[Dict[str, Any]] at the SDK boundary. The SDK internally validates them against the ChatCompletionMessage Pydantic model via ChatCompletionRequest.
The content field is polymorphic: it accepts a plain str for text-only messages or a List[ChatCompletionMessageContent] for multimodal inputs.
The tool_calls field is only meaningful on assistant role messages. The function.arguments field is a JSON-encoded string, not a parsed dictionary.
All Pydantic models inherit from the SDK's custom BaseModel in together.types.abstract.

Page Connections

Double-click a node to navigate. Hold to expand connections.

Principle

Implementation

Heuristic

Environment