Models API Reference

class llm_async.models.message.Message(role: Literal['system', 'user', 'assistant', 'tool'], content: str | list[dict[str, Any]], tool_calls: list[ToolCall] | None = None, reasoning: str | None = None, reasoning_details: list[dict[str, Any] | str] | None = None, stop_reason: str | None = None, original: dict[str, Any] | None = None)

Bases: object

Represents a single chat message.

The preferred way to build messages for acomplete. Accepts plain dicts as well, but using Message provides role validation and type safety.

Example:

from llm_async.models.message import Message

messages = [
    Message("system", "You are a helpful assistant."),
    Message("user", "Hello, how are you?"),
]

Args:

role: One of "system", "user", "assistant", "tool". content: Text content or a list of content parts (for multimodal). tool_calls: Optional list of tool calls attached to this message. original: Raw provider payload, used internally when round-tripping responses.

content: str | list[dict[str, Any]]

original: dict[str, Any] | None = None

reasoning: str | None = None

reasoning_details: list[dict[str, Any] | str] | None = None

role: Literal['system', 'user', 'assistant', 'tool']

stop_reason: str | None = None

tool_calls: list[ToolCall] | None = None

llm_async.models.message.message_to_dict(message: Message) → dict[str, Any]

llm_async.models.message.normalize_messages(messages: Sequence[Message | Mapping[str, Any]]) → list[Message]

llm_async.models.message.validate_messages(messages: Sequence[Message]) → None

class llm_async.models.response.Response(original: 'dict[str, Any]', provider_name: 'str', main_response: 'Message | None' = None, stream: 'bool' = False, stream_generator: 'AsyncIterator[StreamChunk] | None' = None)

Bases: object

main_response: Message | None = None

original: dict[str, Any]

provider_name: str

stream: bool = False

async stream_content() → AsyncIterator[str]

Convenience method to iterate over stream content

stream_generator: AsyncIterator[StreamChunk] | None = None

class llm_async.models.response.StreamChunk(content: str | None, original: dict[str, Any])

Bases: object

Represents a single chunk from a streaming response.

• content: the textual content of the chunk (may be None)

• original: the original parsed JSON chunk from the provider

content: str | None

original: dict[str, Any]

class llm_async.models.tool_call.ToolCall(id: 'str', type: 'str', name: 'str | None' = None, input: 'dict[str, Any] | None' = None, function: 'dict[str, Any] | None' = None)

Bases: object

static from_responses_api_function_call(fc_id: str, call_id: str, name: str, arguments: str) → ToolCall

Create ToolCall from Responses API function call.

function: dict[str, Any] | None = None

static function_call_output(call_id: str, output: str) → ToolCall

Create a function call output ToolCall for Responses API.

id: str

input: dict[str, Any] | None = None

name: str | None = None

to_responses_api_message() → dict[str, Any]

Convert to OpenAI Responses API format message.

type: str

class llm_async.models.response_schema.ResponseSchema(schema: 'Mapping[str, Any]', name: 'str' = 'response', strict: 'bool' = True, mime_type: 'str' = 'application/json')

Bases: object

classmethod coerce(value: ResponseSchema | Mapping[str, Any] | None) → ResponseSchema | None

for_google() → dict[str, Any]

for_openai() → dict[str, Any]

for_openai_responses() → dict[str, Any]

for_openrouter() → dict[str, Any]

mime_type: str = 'application/json'

name: str = 'response'

schema: Mapping[str, Any]

strict: bool = True

class llm_async.models.event.Event(topic: str, payload: dict[str, Any], timestamp: datetime)

Bases: object

Represents a pub/sub event for tool execution.

payload: dict[str, Any]

timestamp: datetime

topic: str

Tool

class llm_async.models.Tool(name: str, description: str, parameters: dict[str, Any] | None = None, input_schema: dict[str, Any] | None = None)

Bases: object

description: str

input_schema: dict[str, Any] | None = None

name: str

parameters: dict[str, Any] | None = None