Skip to content

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 RequestValidationError before 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 no None.

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 version 2026-10-21 removed them; OpenAI's are provider options;
  • system or developer turns inside input (use instructions), audio, files other than PDF documents, images and files in assistant turns, and OpenAI's detail;
  • the built-in tools other than web search and code execution (file search, MCP, web fetch, image generation: a ProviderTool), OpenAI's allowed_tools, and tool results with images or files;
  • reasoning and thinking settings and their content, beyond effort and 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 purpose or Anthropic's ids, OpenAI's uploads in parts (/uploads), and the files that tools make (code execution, skills), whose ids stay in raw of the call.