Unification: what the shared types promise¶
client.generation speaks shared types (GenerationRequest, GenerationResponse, GenerationEvent) for every provider, and so does client.files (FileUpload, StoredFile, ProviderFile). This page lists, field by field, what each shared field becomes for each provider, what is lost on the way, and when a request or a response raises instead.
Two rules decide what is shared:
- A shared type holds only what every provider has. Provider-only data stays in the provider's own types and is reached through
raw, which always holds the provider's whole response or event. - Nothing is dropped silently. A shared request that a provider cannot take raises
RequestValidationErrorbefore anything is sent. - Nothing is invented either. An optional field that is not given is not sent to the provider at all, not even as
null; the shared fields take noNone.
tests/docs/test_unification.py checks this page against the code: every field of the shared types has a row here, and every case in Errors raises the error it names.
Request¶
GenerationRequest maps to OpenAI's POST /responses (CreateResponse, StreamResponse) and Anthropic's POST /messages (CreateMessage, StreamMessage).
| Shared field | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
GenerationRequest.model |
model |
model |
Sent as given; the provider rejects an unknown model with an APIStatusError. |
GenerationRequest.input |
input: a text as is; a list of turns as EasyInputMessage items (role, content) |
messages: a text as one user turn; a list of turns as they are |
A list must not be empty and must end with a user turn: Anthropic rejects an assistant prefill on current models, and OpenAI gives a last assistant turn another meaning. A user turn may hold images and PDF documents, see Content parts. |
GenerationRequest.instructions |
instructions |
system |
System and developer turns are not shared: instructions go here. Not sent when not given. |
GenerationRequest.max_output_tokens |
max_output_tokens, at least 16, reasoning included; without it, the model's limit |
max_tokens, thinking included; required, so without it the adapter's default_max_tokens (16000, room for thinking) |
Must be positive. Below 16 raises for OpenAI. Not sent to OpenAI when not given. |
GenerationRequest.end_user_id |
safety_identifier, up to 128 characters |
metadata.user_id, up to 512 characters |
An opaque id (a hash), never personal data; both providers use it to detect abuse. A longer value raises before sending. Not sent when not given. OpenAI's metadata, which has no Anthropic counterpart, is a provider option. |
GenerationRequest.effort |
reasoning.effort: how deeply a reasoning model reasons |
output_config.effort: all output tokens, thinking and reply |
An Effort: low, medium, high, xhigh or max, the levels both have. OpenAI's none and minimal have no Anthropic counterpart and are not shared (CreateResponse takes them). A model that does not take a level answers 400, an APIStatusError, and so does a model without the setting (checked on 2026-11-07: OpenAI's gpt-4o and gpt-4.1 models, which do not reason, and Anthropic's claude-haiku-4-5; OpenAI's chat-latest takes only medium). Not sent when not given, so the model's own default applies. |
GenerationRequest.output_schema |
text.format: json_schema with the adapter's schema_name ("output" unless set) and strict: true |
output_config.format: json_schema, next to effort in the same object |
The schema is sent as it is: each provider takes its own subset of JSON Schema and answers 400 to the rest, an APIStatusError. The JSON comes back in text; a reply cut by the token limit is invalid JSON, with incomplete_reason MAX_TOKENS. Not sent when not given. |
GenerationRequest.tools |
tools: each a function tool (name, description, parameters, strict; a tool without strict sends strict: null, which OpenAI takes as not strict) |
tools: each a custom tool (name, description, input_schema from parameters, strict only when given) |
A Tool holds what both take: a name (letters, digits, _, -, up to 128 characters, unique in the request), a description, a JSON Schema sent as it is, and strict. Left out, neither is strict; with strict, both need additionalProperties: false, and Anthropic answers 400 otherwise. The built-in tools are their own section; the providers' own tool fields (cache_control, defer_loading, ...) are not shared. Not sent when not given. |
GenerationRequest.tool_choice |
tool_choice: "auto", "none", "required", or {"type": "function", "name"} for a ForcedTool |
tool_choice: {"type": "auto"}, {"type": "none"}, {"type": "any"} for REQUIRED, or {"type": "tool", "name"} for a ForcedTool |
A ToolChoice or a ForcedTool naming one of tools; without tools, or naming another tool, it raises. OpenAI's allowed_tools is not shared. With manual thinking (thinking: {"type": "enabled"}), Anthropic takes only auto and none and answers 400 otherwise. Not sent when not given. |
GenerationRequest.parallel_tool_calls |
parallel_tool_calls |
disable_parallel_tool_use (its negation) inside tool_choice, which is {"type": "auto"} when the request gives no choice |
Only with tools, and not with ToolChoice.NONE, whose Anthropic tool_choice takes no such key; both raise. Not sent when not given, so both allow parallel calls. |
Response¶
| Shared field | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
GenerationResponse.id |
id |
id |
— |
GenerationResponse.provider |
Provider("openai") |
Provider("anthropic") |
— |
GenerationResponse.model |
model |
model |
— |
GenerationResponse.text |
The output_text parts of the message items, joined (as the SDKs' output_text) |
The text blocks, joined |
None without text. Annotations, citations, encrypted or raw reasoning and tool calls stay in raw. |
GenerationResponse.usage |
usage, see Token usage |
usage, see Token usage |
None if OpenAI sends no usage. |
GenerationResponse.incomplete_reason |
REFUSAL if the output has a refusal part; else, for status: "incomplete", MAX_TOKENS for max_output_tokens and OTHER for any other reason (content_filter, max_messages, steered, none given) |
MAX_TOKENS for stop_reason: "max_tokens", REFUSAL for "refusal", PAUSED for "pause_turn" (OTHER before aiollm-anthropic 0.16), OTHER for any other early stop (model_context_window_exceeded, a new reason); None for end_turn, stop_sequence and tool_use (the model waits for tool results, as a completed OpenAI response with function calls) |
Only the values both providers have are shared; the provider's reason is in raw_incomplete_reason. A failed OpenAI response raises an APIStatusError, any status other than completed or incomplete raises APIResponseError, and an Anthropic message without a stop_reason raises APIResponseError. |
GenerationResponse.raw_incomplete_reason |
incomplete_details.reason of an incomplete response |
stop_reason of an early stop |
None when the provider gives no reason, such as a completed OpenAI response with a refusal part. |
GenerationResponse.refusal |
The refusal parts, joined |
stop_details.explanation, else stop_details.category, of a refusal stop |
A refusal is an answer, not an error, as in both SDKs. None if the provider gives no explanation. |
GenerationResponse.reasoning |
The summary_text parts of the reasoning items, joined; there only when the request asks for them with provider_options={"reasoning": {"summary": "auto"}} |
The thinking blocks, joined; a summary on the 5.x models, there only with provider_options={"thinking": {"type": "adaptive", "display": "summarized"}} |
None without a summary, the same for both. OpenAI's raw reasoning_text and encrypted_content, and Anthropic's signature and redacted_thinking, stay in raw. |
GenerationResponse.tool_calls |
A ToolCall per function_call item, in output order |
A ToolCall per tool_use block, in content order |
Empty without calls. A response with calls finished normally (OpenAI completed, Anthropic stop_reason: "tool_use") and waits for their results; with incomplete_reason set, the last call may be cut off, so run none of them and retry with a higher limit. Built-in and server tool calls stay in raw. |
GenerationResponse.native |
The output items, with only the fields OpenAI sent | The content blocks, with only the fields Anthropic sent | The provider's own record of the turn, reasoning included (OpenAI's reasoning items, Anthropic's thinking with its signature); to_turn() puts it in a turn of calls, and in an assistant turn when there are built-in calls or the generation paused. None without output. |
GenerationResponse.raw |
Response |
Message |
Holds everything the shared fields leave out. |
response.to_turn() turns a response into the next item of the conversation: a ToolCallTurn when the model called tools, else an assistant turn (with native when there are built-in tool calls, see Built-in tools). A response with neither calls nor text raises ValueError, unless it paused, and so does one with calls that stopped early, since its last call may be cut off.
Conversation¶
GenerationRequest.input is a text or a list of items: text turns (Turn), turns of calls (ToolCallTurn) and results (ToolResult). Before sending, every adapter checks the order both providers require (each answers 400 otherwise): the results of a turn of calls follow it at once, one per call; no result stands anywhere else; the conversation ends with a user turn or a result.
| Item | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
Turn |
An EasyInputMessage (role, content): a text as is, parts as a list of content items |
A message (role, content): a text as is, parts as a list of content blocks; a user turn right after results joins their message, after them |
A dict without type is a Turn, as before the other items. Only a user turn takes parts. |
ToolCallTurn |
Its native items, when they are OpenAI's (reasoning items with them); else an assistant message with its text and a function_call per call |
An assistant message: its native blocks, when they are Anthropic's (thinking with its signature); else a text block and a tool_use block per call |
Another provider's native is not sent: it cannot read it, so the shared calls go, and the reasoning behind them is lost. For Anthropic, arguments that are not a JSON object raise RequestValidationError. With store: false, OpenAI's reasoning items carry their content only if the call asked for include: ["reasoning.encrypted_content"]. |
ToolResult |
A function_call_output (call_id, output) |
A tool_result block (tool_use_id, content) in one user message with the other results |
Text only; images and files in results are not shared. Anthropic's is_error is not shared: OpenAI has no such flag, so describe a failure in output. |
Content parts¶
Turn.content is a text or a list of parts, at least one, and only a user turn takes parts. An image or a document is its bytes (sent inline, in base64), a URL the provider downloads it from, or a file stored with the provider (see Stored files), exactly one of them; ImagePart.load(path) and DocumentPart.load(path) read a file in a worker thread. Each provider limits the size of a request, of an image and of a document, and answers 400, an APIStatusError, past them; the parts are not checked against those limits.
| Shared field | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
TextPart.type |
input_text |
text |
— |
TextPart.text |
text |
text |
— |
ImagePart.type |
input_image, with detail: "auto", OpenAI's default, which its schema requires |
image |
OpenAI's detail is not shared. |
ImagePart.data |
image_url: a data: URL, the bytes in base64 |
source: base64 with media_type and data |
Not empty. |
ImagePart.url |
image_url |
source: url |
An http or https URL. |
ImagePart.file |
file_id |
source: file with file_id |
A ProviderFile of the provider the request goes to; another provider's raises RequestValidationError. |
ImagePart.media_type |
In the data: URL |
source.media_type |
JPEG, PNG, GIF or WebP, the formats both take; required with data, refused with url and file. |
DocumentPart.type |
input_file |
document |
PDF only: Anthropic's text documents and OpenAI's other file types are not shared. |
DocumentPart.data |
file_data: a data: URL, the bytes in base64 |
source: base64 with media_type and data |
Not empty. |
DocumentPart.url |
file_url |
source: url |
An http or https URL. |
DocumentPart.file |
file_id |
source: file with file_id |
As ImagePart.file; the provider shows the model the name it stored. |
DocumentPart.media_type |
In the data: URL |
source.media_type |
Always application/pdf. |
DocumentPart.filename |
filename; document.pdf when not given, since OpenAI wants one with file_data |
title |
The document's name, which both show the model. Only with data. |
Stored files¶
client.files stores files with OpenAI's /files (CreateFile, RetrieveFile, ListFiles, DeleteFile, DownloadFile) and Anthropic's /files (the methods of the same names). A stored file is named by a ProviderFile, which a part takes as file=; a ProviderFile of another provider raises RequestValidationError before anything is sent, from client.files and from client.generation alike. The library deletes nothing by itself.
| Shared field | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
FileUpload.file |
file |
file |
The multipart part's filename is the name the provider keeps. OpenAI's purpose is a provider option, user_data (a model's input) when not given. |
FileUpload.expires_in_seconds |
expires_after: {"anchor": "created_at", "seconds": ...}, 3600 to 2 592 000 |
expires_in_seconds, 3600 to 7 776 000 |
Positive; outside the provider's range raises RequestValidationError. Not sent when not given, so the file is kept until it is deleted. |
ProviderFile.provider |
Provider("openai") |
Provider("anthropic") |
The provider that stores the file. |
ProviderFile.id |
id |
id |
Not empty. An id reaches every file of the project or workspace: never build one from an end user's input. |
StoredFile.ref |
id, with the provider |
id, with the provider |
— |
StoredFile.filename |
filename |
filename |
— |
StoredFile.size |
bytes |
size_bytes |
None when OpenAI does not know the size yet. |
StoredFile.created_at |
created_at, a Unix time, in UTC |
created_at, in UTC |
— |
StoredFile.expires_at |
expires_at, a Unix time, in UTC |
expires_at, in UTC |
None if the file does not expire. |
StoredFile.raw |
OpenAIFile |
FileMetadata |
OpenAI's purpose and status, Anthropic's mime_type and downloadable stay here. |
client.files.list() goes through every page (OpenAI by after the last id while has_more, Anthropic by next_page), newest first. download() streams the content; OpenAI refuses a user_data file and Anthropic a file it did not make itself (code execution, skills); both answer 400, an APIStatusError.
Tool calls¶
| Shared field | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
ToolCall.id |
call_id of the function_call item (not its id, which stays in raw) |
id of the tool_use block |
The id a result refers to. |
ToolCall.name |
name |
name |
Anthropic's toolset_name and OpenAI's namespace stay in raw. |
ToolCall.arguments |
arguments, the JSON text as sent |
input, written as JSON text; in a stream, the partial_json pieces joined |
The text differs in spacing between the providers, the parsed object does not: parse_arguments() gives it, and raises ValueError for text that is not a JSON object (OpenAI without strict). |
Built-in tools¶
Tools the provider runs itself; see Built-in tools. They go in GenerationRequest.tools beside the functions, and their calls and sources come back in their own fields. The provider columns say what the providers' 0.17 releases do: aiollm-openai and aiollm-anthropic 0.15 send no built-in tool and leave these fields empty, and 0.16 has neither CodeExecution.files nor files.
| Shared type | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
WebSearch |
A web_search tool: allowed_domains in filters.allowed_domains, user_location as {"type": "approximate", ...} |
A web_search_20250305 tool named web_search: allowed_domains, user_location as {"type": "approximate", ...} |
Only what both take. search_context_size and external_web_access (OpenAI), blocked_domains, max_uses and the newer versions (Anthropic) go through a ProviderTool. |
CodeExecution |
A code_interpreter tool with an automatic container (container: {"type": "auto"}); its files as the container's file_ids |
A code_execution_20250825 tool named code_execution; its files as container_upload blocks at the end of the last user message |
files takes the provider's stored files only: another provider's file, or a file of a container (ProducedFile.container_id), raises RequestValidationError (field tools). The container itself, its memory and its network are each provider's own, through a ProviderTool. |
ProviderTool |
definition as one item of tools, checked by the method's tools field |
definition as one item of tools, checked by the method's tools field |
Another provider's tool raises RequestValidationError (field tools), as does a shared tool the provider does not run. |
| Shared field | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
GenerationResponse.server_tool_calls |
A ServerToolCall per web_search_call, file_search_call, code_interpreter_call, image_generation_call and mcp_call item, in output order: kind from the item, status from its status (failed is FAILED), queries from the search's action, code from the interpreter's |
A ServerToolCall per server_tool_use block with the result block that answers it (web_search_tool_result, web_fetch_tool_result, bash_code_execution_tool_result, ...), kind from the block's name; a result with an error code is FAILED with it as error |
The result stays in ServerToolCall.raw, the provider's items of the call. A failed tool is a call with FAILED, never an exception. Empty without built-in tools. |
GenerationResponse.citations |
A Citation per annotation of the output text: url_citation is URL, file_citation is FILE, container_file_citation is CONTAINER_FILE |
A Citation per citation of a text block: web_search_result_location is URL, a document location FILE |
The provider's own fields (Anthropic's encrypted_index) stay in raw and native. Empty without citations. |
GenerationResponse.files |
A ProducedFile per container_file_citation annotation of the output text, once per file: id from file_id, filename, container_id |
A ProducedFile per bash_code_execution_output (and code_execution_output) block of a code execution's result: id from file_id, source_call_id from the result's tool_use_id; no filename, no container_id |
OpenAI names only the files the text refers to, and not the call that made them. Empty without files. |
CompletedEvent.server_tool_calls |
As GenerationResponse.server_tool_calls, from the event's response |
From the blocks of the stream, as GenerationResponse.server_tool_calls |
— |
CompletedEvent.citations |
As GenerationResponse.citations, from the event's response |
From the citations_deltas of the stream |
— |
CompletedEvent.files |
As GenerationResponse.files, from the event's response |
From the result blocks of the stream, as GenerationResponse.files |
— |
ProducedFile.provider |
Provider("openai") |
Provider("anthropic") |
— |
ProducedFile.id |
file_id of the annotation, an id in the container |
file_id, an id of the stored files |
— |
ProducedFile.filename |
filename of the annotation |
None |
Anthropic's name is in the file's metadata: client.files.retrieve(file). |
ProducedFile.container_id |
container_id of the annotation |
None: the file is with the stored files |
Set, only client.files.download takes the file: retrieve, delete, a part's file and CodeExecution.files raise RequestValidationError. Anthropic's download raises it for a file with a container_id. |
ProducedFile.source_call_id |
None |
tool_use_id of the result block |
— |
client.files.download(ProducedFile) |
GET /containers/{container_id}/files/{file_id}/content (DownloadContainerFile) |
GET /v1/files/{file_id}/content, as a stored file |
The container expires with its files; the library keeps none. |
IncompleteReason.PAUSED is Anthropic's stop_reason: "pause_turn": the provider paused a long turn of built-in tools, and the turn is to be sent back to go on. OpenAI has no such stop. With built-in calls, or paused, to_turn() gives an assistant turn with native, which the provider's adapter sends in place of the turn's text, and a conversation may end with such a turn (see Continuing a conversation).
Token usage¶
Cache and reasoning counts are parts of the input and output counts, not added to them. None means the provider did not report the count.
| Shared field | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
TokenUsage.input_tokens |
input_tokens |
input_tokens + cache_creation_input_tokens + cache_read_input_tokens |
— |
TokenUsage.output_tokens |
output_tokens |
output_tokens |
— |
TokenUsage.total_tokens |
total_tokens |
The input above plus output_tokens |
— |
TokenUsage.cache_read_tokens |
input_tokens_details.cached_tokens |
cache_read_input_tokens |
— |
TokenUsage.cache_write_tokens |
input_tokens_details.cache_write_tokens |
cache_creation_input_tokens |
Anthropic's split by cache lifetime (cache_creation) stays in raw. |
TokenUsage.reasoning_tokens |
output_tokens_details.reasoning_tokens |
output_tokens_details.thinking_tokens |
— |
Server tool use, service tier, speed and inference region (Anthropic) and tool usage (OpenAI) stay in raw.
Stream events¶
generation.stream() yields one shared event per provider event. Its type is a GenerationEventType.
| Shared event | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
TextDeltaEvent |
response.output_text.delta |
content_block_delta with a text_delta |
— |
ReasoningDeltaEvent |
response.reasoning_summary_text.delta |
content_block_delta with a non-empty thinking_delta |
Only when a summary was asked for, as GenerationResponse.reasoning; GenerationStream.text() skips it. |
ToolCallStartEvent |
response.output_item.added with a function_call item: its call_id and name |
content_block_start with a tool_use block: its id and name |
One per call, before its deltas. |
ToolCallDeltaEvent |
response.function_call_arguments.delta, the call found by the item's id |
content_block_delta with an input_json_delta, the call found by the block's index |
The pieces of a call joined are its arguments; Anthropic may send none for {}. A delta for an item or block that no call opened raises APIResponseError. |
ToolCallDoneEvent |
response.output_item.done with a function_call item |
content_block_stop of a tool_use block |
The whole ToolCall, before the end of the response, so a tool can start early; the stream can still fail after it. A call cut off by the token limit gets none. |
CompletedEvent |
response.completed, response.incomplete |
message_stop, with the counts of message_start and the last (cumulative) message_delta |
Exactly one, as the last event: a stream that ends without it raises APIStreamInterruptedError, an event after it raises APIResponseError. response.failed and error events raise an APIStatusError. |
ServerToolCallEvent |
response.output_item.added and response.output_item.done with a built-in tool call item: STARTED and DONE |
content_block_start of a server_tool_use block: STARTED; the block of its result: DONE |
The call as known at that moment; IN_PROGRESS until DONE. The deltas of a tool's code and partial images stay OtherEvents. |
OtherEvent |
Every other event, refusal deltas and response.function_call_arguments.done included |
Every other event, signature_delta included (kept in CompletedEvent.native) |
The provider's event is in raw. |
CompletedEvent carries the fields of the whole response that a stream has:
| Shared field | OpenAI | Anthropic | Lost, or when it raises |
|---|---|---|---|
CompletedEvent.type |
GenerationEventType.COMPLETED |
GenerationEventType.COMPLETED |
— |
CompletedEvent.id |
response.id of the terminal event |
message.id of message_start |
— |
CompletedEvent.provider |
Provider("openai") |
Provider("anthropic") |
The adapter's provider, as for GenerationResponse.provider. |
CompletedEvent.model |
response.model of the terminal event |
message.model of message_start |
A stream without message_start raises APIResponseError. |
CompletedEvent.text |
As GenerationResponse.text, from the event's response |
The text_deltas joined |
None without text. |
CompletedEvent.usage |
As GenerationResponse.usage, from the event's response |
As GenerationResponse.usage |
— |
CompletedEvent.incomplete_reason |
As GenerationResponse.incomplete_reason |
As GenerationResponse.incomplete_reason, from the last message_delta |
— |
CompletedEvent.raw_incomplete_reason |
As GenerationResponse.raw_incomplete_reason |
As GenerationResponse.raw_incomplete_reason |
— |
CompletedEvent.refusal |
As GenerationResponse.refusal |
As GenerationResponse.refusal, from message_delta.delta.stop_details |
— |
CompletedEvent.reasoning |
As GenerationResponse.reasoning, from the event's response |
The thinking_deltas joined |
None without a summary. |
CompletedEvent.tool_calls |
As GenerationResponse.tool_calls, from the event's response |
From the tool_use blocks of the stream: content_block_start and the input_json_deltas after it |
An input_json_delta without its tool_use block raises APIResponseError. |
CompletedEvent.native |
As GenerationResponse.native, from the event's response |
The content blocks put together from the stream: each block as it started, its text, thinking and signature pieces joined in, a tool_use block's input parsed from its pieces |
CompletedEvent.to_turn() follows the rule of GenerationResponse.to_turn(). A block whose start did not come is opened from its first piece. Arguments that do not join into a JSON object raise APIResponseError. |
CompletedEvent.raw |
The terminal event | message_stop |
— |
Errors¶
Every case below is raised before the request is sent (requests) or before the shared response is returned (responses). RequestValidationError is a ValueError with provider and the shared field; a pydantic error behind it is its __cause__. Errors of GenerationRequest itself stay pydantic ValidationErrors, for every provider.
| Case | Provider | Shared field | Error |
|---|---|---|---|
empty-turn-list |
any | input |
ValidationError |
zero-max-output-tokens |
any | max_output_tokens |
ValidationError |
unknown-request-field |
any | — | ValidationError |
openai-last-assistant-turn |
OpenAI | input |
RequestValidationError |
anthropic-last-assistant-turn |
Anthropic | input |
RequestValidationError |
openai-max-output-tokens-below-16 |
OpenAI | max_output_tokens |
RequestValidationError |
openai-too-long-end-user-id |
OpenAI | end_user_id |
RequestValidationError |
anthropic-too-long-end-user-id |
Anthropic | end_user_id |
RequestValidationError |
openai-failed-response |
OpenAI | — | APIStatusError |
openai-unfinished-response |
OpenAI | — | APIResponseError |
anthropic-message-without-stop-reason |
Anthropic | — | APIResponseError |
stream-without-completion |
any | — | APIStreamInterruptedError |
tool-choice-without-tools |
any | tool_choice |
ValidationError |
forced-tool-not-in-tools |
any | tool_choice |
ValidationError |
duplicate-tool-names |
any | tools |
ValidationError |
parallel-calls-with-tool-choice-none |
any | parallel_tool_calls |
ValidationError |
tool-call-without-result |
any | input |
RequestValidationError |
result-without-call |
any | input |
RequestValidationError |
anthropic-arguments-not-an-object |
Anthropic | input |
RequestValidationError |
turn-from-response-without-text |
any | — | ValueError |
turn-from-response-cut-mid-call |
any | — | ValueError |
parts-in-assistant-turn |
any | input |
ValidationError |
image-without-media-type |
any | input |
ValidationError |
image-of-unknown-format |
any | input |
ValueError |
part-with-two-sources |
any | input |
ValidationError |
part-with-another-providers-file |
any | input |
RequestValidationError |
files-call-with-another-providers-file |
any | file |
RequestValidationError |
part-with-a-file-of-a-container |
any | input |
RequestValidationError |
files-call-with-a-file-of-a-container |
any | file |
RequestValidationError |
code-execution-with-another-providers-file |
any | tools |
RequestValidationError |
code-execution-with-a-file-of-a-container |
any | tools |
RequestValidationError |
anthropic-download-of-a-file-of-a-container |
Anthropic | file |
RequestValidationError |
openai-expiry-out-of-range |
OpenAI | expires_in_seconds |
RequestValidationError |
anthropic-expiry-out-of-range |
Anthropic | expires_in_seconds |
RequestValidationError |
Provider options¶
Not shared, but reachable through client.generation: create(..., provider_options={...}) and stream(...) send a provider's own fields with that call, as client.files.upload(..., provider_options={...}) does for an upload. Each key is a field of the provider's method with its type, and none is a field the shared request fills, which each provider's test_options.py checks.
| Provider | Options type | Keys |
|---|---|---|
| OpenAI | OpenAIGenerationOptions |
metadata, reasoning (summary, context, mode; its effort is the shared field, and the two are merged), store, previous_response_id, temperature, top_p, include (such as reasoning.encrypted_content for a stateless tool loop), max_tool_calls |
| Anthropic | AnthropicGenerationOptions |
stop_sequences, thinking |
| OpenAI, uploads | OpenAIFileOptions |
purpose |
Not unified¶
These are reached only through the provider's own methods and types, or, where listed under Provider options, through provider_options:
- sampling parameters (
temperature,top_p,top_k): Anthropic API version2026-10-21removed them; OpenAI's are provider options; - system or developer turns inside
input(useinstructions), audio, files other than PDF documents, images and files inassistantturns, and OpenAI'sdetail; - the built-in tools other than web search and code execution (file search, MCP, web fetch, image generation: a
ProviderTool), OpenAI'sallowed_tools, and tool results with images or files; - reasoning and thinking settings and their content, beyond
effortand the summaries; - continuing a stored response (
previous_response_id,store) and stop sequences, which are provider options; - background responses, cancellation and polling;
- listing stored files by OpenAI's
purposeor Anthropic'sids, OpenAI's uploads in parts (/uploads), and the files that tools make (code execution, skills), whose ids stay inrawof the call.