Changelog
This changelog covers public developer-docs and API-contract changes.
On this page 1 of 48
Entries summarize customer-visible documentation and compatibility updates for the paid beta public API. Private operational and deployment notes stay out of the public changelog.
2026-11-17#
- The data retention summary is now version
data-retention-2026-11-17, supersedingdata-retention-2026-11-15. Its new zero data retention section covers how the designation is turned on and off, what changes for your requests, what is still recorded, and how long short-lived state is kept. - New error codes for an API key with a zero data retention policy:
zero_retention_not_supported(403), when the requested model does not support zero data retention yet; andnot_available_for_data_retention(400), when the request asks for web search, another tool that runs outside the model, or a longer prompt-cache lifetime, witherror.paramnaming the field. - eb1 orchestration on
eb1-previewandeb1-frontier-previewnow draws on two newer models, which replace their predecessors. Nothing changes in how you call either model: request and response formats, context windows, prices and the faster setting oneb1-frontier-previeware the same. The first request of a conversation that was in progress at the change may report no cached input tokens, because a prompt cache does not carry over to a newer model.
2026-11-14#
- New: groups in the organization API, one for each of your own customers.
POST /v1/organization/groupscreates a group directly under your organization or inside another group, at most five levels deep, with an optionalexternal_idthat carries your own id for the customer.GET /v1/organization/groupslists groups,GET /v1/organization/groups/{group_id}returns one, andDELETE /v1/organization/groups/{group_id}archives one. Creating or registering a key acceptsgroup_id, the key object shows it, and the key list filters by it; every request made with a key in a group is recorded against that group. New error codes:group_external_id_taken(409),group_limit_reached(409) andgroup_not_empty(409). An organization holds at most 10,000 active groups.
2026-11-12#
- A streamed tool call whose arguments are larger than 1 MiB, such as a large file write, now streams to the end on every format. The stream used to stop with an
internal_errorevent, while the same request without streaming returned the call. - On
/v1/messages, an assistantthinkingblock replayed with"signature": nullis now accepted as unsigned, as an emptysignaturealready was. It used to return400. See Messages. - JSON mode (
response_format: {"type": "json_object"}on Chat Completions,text.format: {"type": "json_object"}on Responses) is now served when the model serving the request has it. It used to be refused with409on every model. When the model serving the request has no JSON mode, the request is still refused with409 capability_conflict, now naming your field inerror.paramandjson_mode_not_supportedindetails.lossiness; send ajson_schemaformat instead. See Structured output conflicts. - New: the organization API manages your organization's API keys with an admin key.
GET /v1/organization/api_keyslists keys,POST /v1/organization/api_keyscreates one,POST /v1/organization/api_keys/registerregisters a key you already hold, andDELETE /v1/organization/api_keys/{api_key_id}revokes one. Admin keys are issued by support and call only these endpoints; a regular key calling them gets403with codeadmin_key_required, and an admin key calling a model gets403with codeadmin_key_route_forbidden. Registering a secret already registered and active in your organization returns200with that key, so a retry is safe; a503with codeapi_key_not_yet_activemeans the key is saved and starts working on its own. New error codes:api_key_already_registered(400),api_key_limit_reached(409),last_admin_key(409),key_change_limit_reached(429) andapi_key_not_yet_active(503). An organization holds at most 500 active keys, counting keys created in the console, and makes at most 60 key changes a minute through the organization API.
2026-11-11#
- During a silent stretch of a Messages stream while a text,
tool_useorthinkingblock is open, eachpingis now followed by an empty delta of that block's own kind (text_delta,input_json_deltaorthinking_delta), the first within about 12 seconds of the last event and then about every 8 seconds. Claude Code abandoned such a stream about 10 minutes into the silence, because its stall timer stops countingpingevents after 30 in a row, and sent the turn again without streaming. The delta adds nothing to the block, and thepingstill arrives as before. See Silence while the model thinks. - A Messages stream that is silent before its first content block, on a request whose
thinking.typeisenabledoradaptive, now carries an emptythinkingblock at index 0: it opens at the first silent tick, about 8 seconds aftermessage_start, gets an emptythinking_deltaafter eachping, and closes before the first text ortool_useblock, which now starts at index 1. This applies to any wait of more than about 8 seconds for the first block, not only a long think, so a streamed answer can be at index 0 or 1 depending on latency: find it by block type, not by position. If the model's own thinking follows, it continues in that block. Claude Code counted onlypingin that wait and abandoned a turn silent for about 10 minutes. Requests without thinking getpingevents only, as before. See Silence while the model thinks. useron/v1/chat/completionsand/v1/responsesnow accepts any string. An empty string or one with leading or trailing spaces used to be refused with a400. Responses echo the value as sent.- A request field Keiro does not accept now gets
400invalid_request_errorwitherror.paramnaming the field, on every format and in both modes. It used to get409capability_conflict. That409already carriedx-should-retry: false, so only clients that ignore that header retried it. Fields Keiro holds back on purpose still get the409: on/v1/messagesservice_tier,containerandbetas, and on/v1/responsesprompt,context_management,access_programsandmoderation. An integerseedon/v1/chat/completionsis now accepted and ignored instead of refused. See Unsupported request fields. - On
/v1/messages, everythinkingblock now carriessignature, as the native API's do: the reasoning summary is unsigned, so itssignatureis"", in non-streaming responses and in the stream'scontent_block_start. The Anthropic SDKs' strict response validation no longer rejects these replies, and a client that replays the block unchanged is accepted. See Messages. - When an upstream dependency fails and says when to retry, the
upstream_server_error(502, or500when the upstream answered500) now carries that interval asRetry-Afterandretry-after-ms, and a stream's error event carries it asretry_after_seconds, on every format. It used to carry none, so SDKs retried after their own short backoff. An interval longer than a day is not passed on. - An upstream rate limit's retry interval now keeps its precision:
1.9seconds is no longer rounded down to1, aretry-after-msinterval is honoured, and a half-second interval is no longer stretched to 60 seconds. See Rate and spend limits. POST /v1/v1/chat/completions,POST /v1/v1/responsesandPOST /v1/chat/completions/(a doubled/v1in the base URL, or a trailing slash) now return404with codenot_foundwhatever the API key, so a misconfigured base URL reads as a wrong path. A method other thanPOSTon/v1/messagesnow returns405with codemethod_not_allowedandAllow: POST, whatever the API key. Before, a missing or invalid key got401on all of these. Every other request with a missing or invalid key still returns401. See Errors.- A stop sequence (
stopon Chat Completions and Responses,stop_sequenceson Messages) now ends the turn at the match on every model. On some models the reply used to stop showing text at the match but could still end with a tool call the model made after it, reported asfinish_reason: "tool_calls"orstop_reason: "tool_use". Now nothing after the match is returned: no tool call, reasoning or search item, and the turn ends withfinish_reason: "stop",stop_reason: "stop_sequence"with the matchedstop_sequence, or a completed Responses turn. A tool call made before the match still ends the turn as a tool call, and a stop sequence that a tool call splits in two does not match; streaming and non-streaming requests now agree on both. If your agent sends a general stop sequence such as"\n\n"together with tools, expect a text-only turn where it used to get a tool call after that text. On eb1 requests, output tokens count the reply you receive, so a tool call dropped this way is no longer counted. On direct model requests, output tokens are the model's own count and still include what it wrote after the match, as before. context_length_exceeded(on Messages, a message startingprompt is too long) now means only that the request's input is longer than the model's context window. An error whose description only mentioned a context window used to arrive as that400, which made coding agents compact the conversation. On every format it now arrives as what it is: a server error keeps its status and retry signal, and a rejection of something else in the request is aninvalid_request_error.- Two errors that a client retry does not fix no longer ask for one. An
upstream_auth_error(502) is the platform's to fix: the platform now takes the refused upstream credential out of service itself, and the error carries"retryable": falseandx-should-retry: false, on every format, and a stream's error event says"retryable": false; SDKs used to retry it. A per-request token-budget or per-request spend-cap429no longer carriesRetry-After, as announced; it keepsx-should-retry: falseand"retryable": false. See Errors and Deterministic denials. - On Responses, the
response.failedevent that ends a failed stream now carries inresponse.outputthe items the stream had already finished (each one sent before in aresponse.output_item.doneevent), in order. It used to carry an emptyoutput. An item still open at the failure is not included. See Handle in-band errors. - A non-streaming request that had already received its
200(after 30 seconds of work) and then failed in a way a retry may fix, such as an upstream fault, a stalled model call or a gateway restart, returned an error JSON body under the200. The OpenAI and Anthropic SDKs read that body as a reply with empty fields and did not retry. The connection now closes before the body is complete, so your client raises a connection error and the OpenAI and Anthropic Python SDKs retry the request. A failure a retry cannot fix still arrives as the same error body under the200. See Long non-streaming requests.
2026-11-10#
- During a silent stretch of a stream, Chat Completions and Responses now send an event a client's stall timer counts on every keepalive tick, the first within about 12 seconds of the last output and then about every 8 seconds, each right after the
: keepalivecomment, which still arrives as before. See Silence while the model thinks. - Chat Completions: the chunk with one space indelta.reasoning_contentnow comes in every phase of the stream, not only before the first output; it used to carry an emptydeltaafter output had started. - Responses: after the first output item, the event iskeepalive; that stretch used to carry comments only. A client that turns on the OpenAI SDK's strict response validation, which is off by default, rejects it. - Messages is unchanged.
2026-11-09#
- Some prompt content was left out of
input_tokens(prompt_tokenson Chat Completions), so it was not billed and did not count toward rate limits or the model's input window. It now counts as text, like the rest of the prompt. See Usage and billing. - On/v1/responses: tool calls and tool results in every accepted spelling. That coverstool_useandtool_resultblocks, whether nested in a message or sent as items;shell_callcommands andshell_call_outputstdout and stderr;tool_search_callarguments and the tool definitions intool_search_output;function_callarguments sent as a JSON object; assistantthinkingparts; and plain strings in theinputarray. - On/v1/messages:thinkingblocks you send back in assistant turns. Athinkingblock that eb1 returned beside its sealedredacted_thinkingblock still counts once, through the sealed block. - On/v1/responsesand Chat Completions: assistant refusals you send back. Requests whose history carries this content now report and bill more input tokens, and a very large one can reach a rate limit or the input window where it did not before. Newly counted content also goes through the check the rest of the prompt already had: text with one unbroken run of 524,288 or more characters that cannot be split into tokens (for example one character repeated, or one very long word) is refused with status400, type and codeinvalid_request_error, not retryable. Such a request was admitted before when the run sat only in the newly counted content. Tool output in the shapes that were already counted, such asfunction_call_output, has always been checked this way. - A replayed
reasoningitem that carries acontentlist was counted twice, as text and as encrypted reasoning. It now counts once, so these requests report and bill fewer input tokens.
2026-11-07#
- The Keiro Python client no longer treats a cut or failed stream as success, and every outcome names the gateway request id. Changes reach you with the next
keirorelease: - A stream that ends before its final event ([DONE], orresponse.completed/response.incompleteon Responses) raisesKeirErrorwith codestream_truncated. Before, it returned as if complete, andchat(stream=True)built a full-looking answer. The client doesn't retry it, because the gateway already accepted the request. - Aresponse.failedevent raises the failure's own code, before or after the first text. Before, it was reported as a protocol error, or passed through as an ordinary event. -request_idis on every reply (response.request_id, fromClientand fromkeiro.models), on everyClientstream (chat_stream()andresponses_stream()now return aGatewayStreamthat iterates as before), and on everyKeirErrorraised for a response. It is the response'sX-Request-Id, except that a stream error event's own id wins. An error raised before any response arrives hasrequest_id=None. -chat(stream=True)keeps the completionidandfinish_reason. -Client.batch(raise_on_error=False)puts each failure's exception in its slot instead ofNone. - When an upstream provider keeps failing, Keiro pauses requests to it for a short cooldown. A request refused during that pause now gets
503provider_unavailable, with the time left in the cooldown asRetry-After(orretry_after_secondsin a stream's error event). Before, it got429rate_limit_exceededwith a one-second retry hint and a message saying Keiro had retried, though nothing had been sent. A pause now covers only the models that share the failing provider limit, and a failing BYOK key pauses only that key. A pause for an exhausted quota or credit balance answers as that quota did:429insufficient_quota, not retryable, with noRetry-After. - A daily or monthly spend-cap refusal now says why, and is final only when the money already spent leaves this request no room: - Spend has reached the cap, or what is left is less than this request's estimated cost. The
429carriesx-should-retry: falseand"retryable": false, and noRetry-Afterorretry-after-msheader. Before, itsRetry-Afterran to the end of the UTC day or month, and some clients slept that long. The reset time moves to the newerror.details.resets_at(an RFC 3339 UTC timestamp) and the message. - Requests already running hold the rest of the cap. The429stays retriable, now with a 5-second horizon instead of one running to the end of the period. Clients that readRetry-Afteron a final refusal to schedule work should readdetails.resets_atinstead. When both a daily and a monthly cap refuse, a final monthly refusal is reported first, since its reset comes last; a cap held by running requests never hides a final one. The messages name the next step: wait for the reset, lower the output token limit (max_tokens, ormax_output_tokenson Responses), or contact support to raise your organization's cap. A cap set on an API key is named as that key's, checked against your organization's spend. A prepaid balance short of a request's estimate is named as such, with how to add credit. OpenAI-compatible SDKs stop at once on a final refusal; installed Keiro Python clients give up after a few seconds of short backoff, and the next release raiseskeiro.SpendCapErrorat once. Codes, types, statuses anddetails.dimensionare unchanged. See Rate and spend limits. - Spend-limit
429s no longer carryerror.details.estimateor a cost figure in the message. The figure was an internal estimate, not the price of the request; the per-request spend cap denial carried it before today. Token-limit denials keepdetails.estimate, which is a token count. See Errors. - A PDF input that needs more processing than Keiro allows now returns
400withcodepdf_too_complex, which says so. Previously it returned a retryable503that failed the same way on every retry. Reduce the file's page count or complexity, or split it. See Errors. - Rate-limit and capacity
429s now say whose limit it was. A requests-per-minute, tokens-per-minute or concurrency denial names your organization's limit or the API key's own limit, anddetails.binding_scopeis now present on request and concurrency denials too. A key's own limit counts requests from every key in your organization, and the message says so. Platform load, shared capacity and an upstream429say they are not a limit on your organization or API key; before, the last two read "Rate limit exceeded." like your own limits. Codes, types, statuses and headers are unchanged. See Rate and spend limits. - The beta plan's limits are now published in a new Invite plans table: the requests, tokens and concurrent requests a beta organization gets for each public model, and its spend caps (no daily cap, $5,000 a month, $240 per request). Benchmark and Enterprise plans are set per organization. The console and the response headers stay authoritative, and per-model limits follow platform capacity, so they can change. Enterprise plan rate limits are now at least the beta plan's for every public model. See Invite plans.
- A Responses stream that fails after
response.creatednow ends with the standardresponse.failedevent right afterresponse.error, carrying the same error. Clients that read only the standard terminal events, such as Codex, now show Keiro's message instead of reporting that the stream closed early. See Handle in-band errors. - Messages stream error events now use the same Anthropic
error.typeas the non-streaming error body for the same failure, for exampleoverloaded_errorwhen the service restarts mid-stream andtimeout_errorwhen a request stops making progress. Previously these frames saidserver_error. A504on Messages, streaming or not, now readstimeout_errorinstead ofapi_error, and a cancelled Messages stream's error event carriescode: "cancelled"with typeapi_error. - An exhausted upstream quota now answers
429withcode: "insufficient_quota"andretryable: false, streaming or not, as Errors describes. Most models answered a retryable429rate_limit_exceededinstead, which told a client to retry a request that could not succeed until the quota was restored.
2026-11-06#
- A streaming
/v1/messagesrequest where the model called a tool with no arguments could end ininternal_errorafter the call. It now arrives as atool_useblock with{}as its input. - On a streaming Chat Completions request, a tool call whose arguments arrived only with the final response now gets them in a
tool_callschunk before the one withfinish_reason. Before, the call could end with noargumentsat all. - When a client closes a stream, Keiro now stops the model call right away, on every surface and most model paths. Previously a call that was silent at that moment could run on to its end. What you are billed is unchanged. See Stream lifetime.
- Streaming now describes what a client receives while the model thinks, why an idle timer shorter than that thinking ends the request, and how to set one.
- A request the model declines now costs nothing if no text reached you, on every endpoint, streaming or not. Some streaming requests with tools used to bill the declined attempt. A request that ran hosted web search first still bills that work. See Usage and billing.
- A request body that is still arriving is no longer cut off. Keiro now refuses a body with
408request_body_timeoutonly when none of it arrives for 60 seconds; before, a body that took longer than 60 seconds in total to upload got the408even while it was still arriving, and failed the same way on every retry. An organization can upload at most its concurrency limit of request bodies at once; one more gets the usual concurrency429before Keiro reads it. - The faster setting on
eb1-frontier-previewis now available on beta accounts:"service_tier": "ultrafast"on Responses and Chat Completions, and"speed": "fast"on Messages. See Chat Completions. - While a model works silently on a streaming Chat Completions request, before its first text or tool call, the idle chunk Keiro writes about every 16 seconds (at most about 24) now carries one space in
choices[0].delta.reasoning_contentinstead of an emptydelta. A client whose stall timer ignores empty deltas now sees progress during a long think. Keiro writes this value, not the model, and it is not a readable status. It is not billed, stays out ofdelta.content, and is dropped if a client sends it back asreasoning_contenton a saved message. Some clients show it as an empty reasoning block. A timer that trims whitespace, or that counts onlycontentortool_calls, does not count it, and once text or a tool call has started these chunks keep an emptydelta. See Streaming. - A model refusal that ends a request as an error no longer asks you to retry. It keeps
codeupstream_error,typeapi_errorand status502(or a stream error frame after200), but now carriesretryable: false,x-should-retry: falseon non-streaming requests, and the messageThe model declined this request. Rephrasing or changing it may help; sending it again unchanged is likely to get the same result.Previously it read as a retryable upstream failure. This applies to direct model requests, and to eb1 requests when Keiro can't handle the refusal itself. - A non-streaming eb1 request with no tools, whose model thought and then declined, now gets the same handling as its streaming equivalent. It used to return a retryable
502. See Model refusals. - A streaming eb1 request whose model started a tool call and then declined now ends with the refusal terminal described in Model refusals. It used to continue with text from another attempt after the call had started, then end with a retryable error. When no text was delivered before the refusal, it isn't billed.
2026-11-05#
eb1-frontier-previewnow offers opt-in ultra requests. Send reasoning effortultra(reasoning.efforton Responses,reasoning_efforton Chat Completions,output_config.efforton Messages) to have eb1 orchestration use more models and deeper reasoning on a request. It is available on paid self-serve plans and on alpha, beta and enterprise accounts. These requests cost more and can take many minutes. The newx-keiro-reasoning-moderesponse header reports the mode the request ran in. Effortmax, requests without an effort, and other models are unchanged. See Responses.- A tool call cut off by the output limit or a content filter now ends as that stop instead of an error. Some streaming
/v1/responsesrequests previously ended in aninternal_errorevent; they now end inresponse.incomplete, with the unfinished call closedstatus: "incomplete". Chat Completions reportsfinish_reasonlengthorcontent_filter, where it could previously reporttool_callsor return an error. An unfinished call has nothing to run, so clients should not execute it.
2026-11-03#
- When eb1 model selection does not finish in time, the response is now
503 server_errorwith the new coderoute_timeoutand the message "Model selection timed out. Retry the request." It is retriable and carries aRetry-Afterhorizon. These failures previously returnedroute_capacitywith capacity wording, though no capacity limit was involved. No other model is substituted, as before.route_capacitynow means only that the platform is at capacity. Clients that retryroute_capacityshould retryroute_timeoutthe same way. See Errors. - Some non-streaming eb1 responses that contained both text and a tool call counted only the tool call in
output_tokens(completion_tokenson Chat Completions), so they reported fewer output tokens than the same answer streamed. They now count and bill the text too, on Responses, Chat Completions and Messages. Streaming requests are unchanged. See Usage and billing. - Some streamed eb1 responses on Messages and Chat Completions whose output began with a tool call reported zero output tokens even though the call was delivered, and the call was not billed. They now count and bill the tool call's arguments.
- Some non-streaming eb1 responses that contain both text and a tool call now return the text on Responses, as an assistant
messageitem ahead of the call, and on Messages, as atextblock ahead of thetool_useblock. Those surfaces used to drop it; streaming and Chat Completions already returned it.
2026-10-30#
- Fewer requests to eb1 models end in a partial answer or an error after a safety decline. When a non-streaming request is declined after output has begun, the platform discards that partial output and makes one further attempt, returning that answer as the response. Only the returned answer is billed. When a provider rejects a request's content on an eb1 model, the caller now receives the safety-refusal response with zero usage instead of an HTTP 400 or a stream error. A streaming request declined after its output has started is unchanged, and requests to a named model keep their rejection.
2026-10-29#
- A request whose body is sent compressed, with a
Content-Encodingheader such asgzip, now returns415unsupported_media_type. Send request bodies uncompressed;Content-Encoding: identityis accepted. On the Messages endpoint,415errors now carry theinvalid_request_errortype instead ofapi_error. See Errors.
2026-10-27#
- On eb1 models, reasoning effort
noneno longer caps reasoning atlow. Likeultra, it sets no cap: eb1 chooses the depth on its own, as it does for a request without an effort, andnonedoes not turn reasoning off. Codex sendsnoneon every request, so Codex sessions on eb1 models now reason at the depth eb1 chooses. Someeb1-fast-previewrequests withnoneorultrafailed with the retryable502upstream_error; they now succeed. See Models. - On other models, an effort value outside a model's effort vocabulary, such as
ultraon a model whose efforts stop atmax, now returns400invalid_request_errorwithparamreasoning.effortinstead of a retryable500internal_error. A supported value above the model's ceiling already returned this400.
2026-10-26#
- A model edit that fails the gateway's patch verification now returns the new retryable
model_tool_call_invaliderror (502,api_error) instead ofupstream_error. Retrying samples a new edit. See Errors.
2026-10-10#
- A run is now cancelled for lack of upstream progress after 10 minutes of complete silence, up from 5. Long silent reasoning between 5 and 10 minutes no longer ends with the retryable
gateway_timeouterror. See Streaming.
2026-10-09#
- Context-overflow errors (
context_length_exceeded) now name the largest item in the request and its approximate size, for exampleThe largest input item is tool output call_8f2k, about 735K tokens, and say when a large share of that item is undecodable bytes (U+FFFD), which usually means a binary file was read as text. The same facts are indetails.largest_input_item. This applies on Responses, Chat Completions and Messages, including streams; on Messages the sentence followsprompt is too long: {N} tokens > {M} maximum. See Errors.
2026-10-07#
- A request now lives as long as the model keeps working. The per-effort wall-clock ceilings and idle windows are retired: no clock ends a stream or a non-streaming request while the model is still producing work, including long silent reasoning. A run ends early only when the model sends nothing for 5 minutes (the retryable
gateway_timeouterror, as an error frame on streams) or when your client disconnects, which now cancels the in-flight model calls on every endpoint. Streams no longer end with thestream_idle_timeoutorstream_ceiling_timeoutincomplete terminals. See Streaming. - A non-streaming request whose reply is not ready after 30 seconds now receives its
200status and headers immediately, then one space every 15 seconds, then the JSON body, so client read timeouts that bound silence keep reading. A failure after that point arrives as the endpoint's error JSON body under the200. Requests that finish within 30 seconds are unchanged. See Streaming. - New retryable error code
gateway_restarting(503, shortRetry-After): a service restart that ends a request after its reply began closes the reply with this error, in-band in the JSON body or as an error frame on a stream, instead of cutting it off. Retry the request. See Errors. - On eb1 models, a request's reasoning effort is now a ceiling: eb1 never reasons above it. Previously eb1's own choice could replace a lower requested effort.
reasoning.efforton Responses,reasoning_efforton Chat Completions, andoutput_config.efforton Messages all apply;noneandminimalcap atlow, andultrasets no cap. Requests without an effort are unchanged. See Models. - A request whose strict schemas exceed what the model accepts per request (too many strict tools, optional parameters or union-typed parameters across its strict tools and output format) now returns
400with codestrict_schema_too_complexand guidance to reduce them or send the tools withoutstrict, on Responses, Chat Completions and Messages, including streams. It previously returnedinvalid_requestwith a generic message. The request is not retried.
2026-10-06#
- Codex model limits now refresh from the gateway catalog instead of an install-time file. Setup migrates the managed Keiro profile to live discovery; older installs need one setup rerun and Codex 0.160.1 or newer. Updated Claude Code and OpenCode launchers resolve context windows before every launch. Pi's provider extension discovers limits at startup and on model refresh. Generated configuration previews remain review examples, not permanent client limits.
- An upstream error relayed mid-stream now carries
retryablein the nestederrorobject on Responses, Messages and Chat Completions streams, like every other stream error frame. Upstream rate limits, overload, and upstream server errors and timeouts areretryable: true, matching the retryable429and5xxthe same failure returns without streaming. Invalid requests, context-length and content-policy rejections, authentication and permission failures, missing models, exhausted quota, and unrecognized upstream errors areretryable: false, and theirmessageno longer advises a retry. On Chat Completions, read the nestedretryablerather than theprovider_errorcode's default. - The same rules now apply when an upstream error arrives while the platform reads an upstream response in full, including for non-streamed requests. Invalid requests and context-length or content-policy rejections return
400, and exhausted quota returns the non-retryable429insufficient_quota. Authentication, permission, missing-model and unrecognized upstream errors keep502upstream_errorbut now carryretryable: falseandx-should-retry: false, with noRetry-After. Upstream rate limits, overload, and server errors stay retryable.
2026-10-05#
- On
/v1/responses, requests to models outside the eb1 family now report usage in the standard Responses shape that eb1 models already use, on streamed and non-streamed responses alike:input_tokens,input_tokens_details.cached_tokens(withcache_write_tokens),output_tokens,output_tokens_details.reasoning_tokens, andtotal_tokens. These responses previously could carry chat-styleprompt_tokensandcompletion_tokenskeys or top-levelcache_read_tokensandreasoning_tokens, and reported cache reads outsidecached_tokens. Read the standard fields instead; billing is unchanged. /v1/messagesnow forwards caller-suppliedoutput_config.task_budgetto models outside the eb1 family that support it, for both buffered and streaming requests. Use{"type": "tokens", "total": N}with integerN >= 20000. Malformed budgets and budgets on unsupported models oreb1ids return400before dispatch. Requests without a task budget keep their existing behavior;/v1/responsesgains no new fields. See Task budget.- A response-format schema rejected for its complexity now returns
response_format_schema_too_complexwith guidance to simplify the schema and retry, on Responses, Chat Completions and Messages, including streams. The request is not retried.
2026-09-28#
eb1-delta-previewandeb1-preview-deltanow serveeb1-preview: the same model at the same pricing. Responses to requests that use either identifier nameeb1-preview. Both identifiers remain accepted on requests and in stored conversations until 2026-10-28 (UTC) and may stop being accepted after that date; useeb1-preview.- Fewer requests to eb1 models end in the safety-refusal response. When a request is declined before any output is produced, the platform now makes one further attempt in more cases than before and returns that answer as the response. Only the returned answer is billed; the declined attempt is not. A request that is still declined receives the same safety-refusal response as before, with zero usage.
2026-09-25#
- When a platform dependency is temporarily unavailable, the
503provider_unavailableresponse now advertises a retry horizon between 5 and 15 seconds inRetry-After,retry-after-ms, and the stream frame'sretry_after_seconds, instead of one second. The value varies per request so clients refused together do not retry together. A stream that fails mid-response for the same reason now ends with the sameprovider_unavailableframe instead ofinternal_error. - Every other retriable response that carries
Retry-Afternow advertises a horizon that varies per request, so clients refused together do not retry together. The value is the previous horizon lengthened by up to a quarter, and by at most 30 seconds; it is never shorter than before, and a horizon of 60 seconds or less stays at or below 60 seconds so the OpenAI and Anthropic SDKs keep honoring it.retry-after-ms,error.details.retry_after_seconds, and the stream frame'sretry_after_secondscarry the same per-request value.Retry-Afterrounds it up to a whole second, so a response that sentRetry-After: 1now almost always sends2; readretry-after-msfor the spread. A503raised by a platform lookup outage now carriesretry-after-msalongsideRetry-After, and a503for a request that timed out waiting for serving capacity advertises at least the time it already waited instead of one second. See Retry-After. eb1-frontier-previewnow reports acontext_window(andmax_input_tokens) of869811in/v1/models, up from400000, and accepts prompts up to that size on every request, instead of refusing some long prompts. The other public eb1 models stay at400000. The figure is a floor the API honors whatevermax_output_tokensyou set, and a prompt past it returnscontext_length_exceededwith the limit. Requests remain subject to the organization's per-minute token budget (request_exceeds_capacity). Existing Codex, OpenCode, and Pi setups pick up the new window on their next setup run; Claude Code sessions keep the default model's400000window.
2026-09-10#
- Reasoning tokens on eb1 models are now itemized inside the output count on every surface:
output_tokens/completion_tokensis the delivered text plus the reasoning tokens,total_tokensis input plus output, and the reasoning share appears inoutput_tokens_details.reasoning_tokens(Responses) andcompletion_tokens_details.reasoning_tokens(Chat Completions); on Messages it is insideoutput_tokensas on Anthropic's own API. The reasoning count is the model's own report and is no longer clamped to the length of the reply, so the four counts on a record multiply by the rate card to exactly the amount billed. See "Reasoning tokens" under Token counting on the usage and billing page.
2026-09-09#
- A request whose body does not arrive in full within 60 seconds of the gateway starting to read it is now refused with
408and the new error coderequest_body_timeout. The error is retriable, and the OpenAI and Anthropic SDKs retry a408by default. Before this change a stalled upload held its connection open until the server restarted.
2026-09-07#
- Token counts on every eb1 model are now reported and billed in one unit, the
o200k_basemeter, on every request. The same request body yields the sameprompt_tokens/input_tokenson every call,completion_tokens/output_tokensis the meter count of the delivered output, andtotal_tokensis their sum. Cache-read and cache-write counts are reported as proportional subsets of the metered prompt. The 400,000-token input window,/v1/messages/count_tokens, and rate-limit token accounting use the same unit. Counts you can reproduce locally withtiktoken'so200k_baseencoding. - Follow-up corrections to the meter: image and file requests now report the same prompt count that is billed (the per-part media minimum), tool results sent as content-part lists and custom tool outputs are counted, and a safety refusal the gateway authors carries zero usage on streams as it already did on synchronous requests.
POST /v1/messages/count_tokensnow counts an accepted body exactly as the request would be billed, tool definitions and tool history included; a body the Messages endpoint would reject still receives an advisory estimate.- A streamed request that ends early after delivering output (client disconnect or provider error) is billed for the delivered output and its prompt, in meter units, whether or not the provider reported usage; a stream that delivered nothing is not billed.
2026-09-06#
- Content-limit refusals now return
400 invalid_request_errorwith media-removal or compaction wording recognized by Claude Code. Image, PDF, replay-byte, and content-node limits are unchanged; depth-only errors remain count-free. - A request that reaches the platform while an internal service is restarting now completes on a live instance of that service when one is reachable within the request's retry budget. When several instances are down at once and none of them has yet been re-probed, the retries can still all land on down instances and the request fails. When no instance can take the request, the response is
503 server_errorwith the new coderoute_unavailable, a retriable condition carrying aRetry-Afterhorizon and the message "A platform service is restarting. Retry the request shortly." These failures previously surfaced as503 provider_unavailablewith "Capacity is temporarily limited", wrongly implying an upstream dependency and a capacity condition; no upstream is involved and an unchanged retry succeeds once the restart completes.provider_unavailableremains reserved for genuine upstream unavailability. - The 400,000-token eb1 input window uses unpadded cl100k prompt counts, including tool definitions and replay estimates. Gateway context-overflow errors now report their input count and binding limit in that same unit, so clients can compact and retry using consistent counts. Messages keeps the native
prompt is too long: N tokens > M maximumgrammar; provider rejections retain the provider's own counts.
2026-09-04#
- Function tools declared with
strict: truenow keepstrict: trueon every request, so tool-call arguments are validated against your schema; previously the flag could be dropped without notice on some requests. This applies on/v1/responses,/v1/chat/completions, and/v1/messagesalike, and to thecustom+input_schematool spelling. A strict schema must setadditionalProperties: falseand list every property underrequired; a strict declaration whose schema does not can now return400instead of running without the guarantee. Tool declarations lead the prompt-cache prefix, so the first strict request after this change can write a new cache entry.
2026-09-03#
- Replayed tool history is validated once per request before any model is called. A duplicated
call_id, a result for an unknown call, a second result for the same call, or a call left unanswered before the next user turn now returns400with codeconversation_invariantand the offendingcall_id, on/v1/responses,/v1/chat/completions, and/v1/messagesalike, instead of a less specific error that varied by request. - Streaming requests that replay function-call history can now be served by more of eb1's serving capacity. Requests that set
parallel_tool_calls: falseare still honored. - Tool names longer than 64 characters or using characters outside
[A-Za-z0-9_.:-](long MCP names, for example) now work on every eb1 request; the model sees a stable alias and every emitted call carries the name you declared. - Freeform
apply_patchcalls served through the compatibility path now carry the samecall_eba1_…identity every other tool call carries. Ids issued under the earliercall_eb2.…format keep working for one release.
2026-09-02#
previous_response_idis now honored on/v1/responsesfor every eb1 model. Each response is retained for 24 hours, scoped to your organization, unless the request setstore: false; a follow-up request that names the id continues the conversation without resending earlier turns. An unknown or expired id returns400with codeprevious_response_not_found, matching the OpenAI contract. Responses larger than 1 MiB are served normally but not retained for continuation./v1/messagesnow forwardsoutput_config.effortandthinking: {"type": "adaptive"}as the request's reasoning effort instead of dropping them; effort above a model's ceiling is lowered to that ceiling./v1/responsesacceptstool_choice: {"type": "allowed_tools"}, assistantrefusalcontent on replayed turns, array-valuedcustom_tool_call_output, andinput_image.detail: "original".item_referenceitems andconversationreturn a400naming the parameter.- Tool-call identities are now gateway-issued on every surface. A Responses
call_id, a Chat Completionstool_calls[].id, and a Messagestool_use.idfor the same call all render as the samecall_eba1_…alias; hosted web-search correlation ids render ashist_eba1_…and output item ids asitem_eba1_…. Replay them verbatim in continuation turns exactly as before; ids issued by earlier responses keep working. Provider-private continuation fields (such asthought_signature) no longer appear in customer payloads; the gateway carries them across turns for you. /v1/messagesnow serves Anthropic-native web search with both current spellings,web_search_20250305andweb_search_20260209, on every eb1 model, and itsserver_tool_useandweb_search_tool_resultblocks come back in place. Previously the native declaration was refused.- Anthropic's client-executed agent tools (
bash_20250124, thetext_editor_*versions, andmemory_20250818) are accepted on/v1/messagesand served natively where the model supports them; the model's version support still applies. Previously these declarations were refused as unknown tools.
2026-08-27#
eb1-fast-previewnow reports acontext_window(andmax_input_tokens) of400000in/v1/models, up from240000. The larger window is now served, and the published figure tracks the enforced serving bound (capped at the product-wide400000ceiling shared by every eb1 model). As before, the figure is a floor the API honors on every request. Existing Codex setups pick up the new window on their next setup run.
2026-08-21#
- A platform-internal admission refusal that previously surfaced as
500 internal_errornow returns503 server_errorwith coderoute_capacityand aRetry-Afterhorizon, the same retriable contract introduced on 2026-08-05. No upstream is involved and an unchanged retry usually succeeds immediately; clients that already honorroute_capacityneed no changes.
2026-08-20#
- The Codex model catalog written by the Keiro installer now declares the one reasoning level eb1 models accept. In stock Codex, choosing a model from
/modelpreviously applied the change but left the picker on screen until Esc; the picker now closes on selection. Existing installations pick this up by rerunning the installer, which rewrites~/.codex/keiro.jsonin place. See Use eb1 with Codex.
2026-08-10#
- New setup guides for two additional coding agents: OpenCode registers Keiro as an OpenAI-compatible provider in
opencode.json, and Pi adds a Keiro provider entry to~/.pi/agent/models.json. Both pages appear in the Build navigation alongside the existing Codex, Claude Code, and Omnigent guides.
2026-08-08#
/v1/messagesusage adopts Anthropic's native disjoint input-side semantics for all callers, effective with the next deployment:input_tokensexcludes the cached portions of the prompt, andinput_tokens + cache_read_input_tokens + cache_creation_input_tokensequals the full prompt. The previous additive-subset shape — the full inclusive count ininput_tokenswith the cache fields as subsets of it — is retired. Clients that readinput_tokensas the inclusive total should sum the three input-side fields to recover it; responses with zero cache activity are unchanged. See Messages.- Prompt tokens served from a prompt cache now bill at 0.1x the model's input rate on every public model. Cache writes carry no surcharge and bill at the standard input rate. The usage fields that report cached prompt portions are unchanged; only the billed amount drops. See Usage and billing.
2026-08-05#
- Requests refused by a platform-internal capacity gate now return
503 server_errorwith the new coderoute_capacity, a retriable condition carrying aRetry-Afterhorizon. These refusals previously surfaced as502 upstream_server_error, wrongly implying an upstream dependency; no upstream is involved and an unchanged retry usually succeeds within seconds.provider_unavailableremains reserved for genuine upstream unavailability.
2026-08-02#
eb1-previewandeb1-efficient-previewnow report acontext_window(andmax_input_tokens) of400000in/v1/models, up from120000;eb1-fast-previewreports240000. The previous figures understated the window the API was already serving. The published figure remains a floor the API honors on every request;eb1-frontier-previewis unchanged at400000. Existing Codex setups pick up the new windows on their next setup run.- Context-overflow errors now report the enforced bound. The
Minprompt is too long: {N} tokens > {M} maximum(anddetails.context_window) is the largest limit the rejected request was actually evaluated against, in the same units as{N}, rather than the requested model's published window;{N} > {M}holds on every such error, so clients that trim by the reported gap now trim the right amount.
2026-07-29#
- Model IDs the API does not offer now return a uniform
404 model_not_foundthat names the public IDs, with403 model_not_availablereserved for public models your plan does not include. Previously some unknown IDs surfaced as availability errors. - Streamed Messages responses carry
thinkingsummary blocks, delivered throughthinking_deltaevents, when extended thinking is enabled. These blocks contain summary text constructed by the API and are unsigned; do not round-trip them as provider-signed thinking blocks. POST /v1/messages/count_tokensnow applies the same per-part minimums to image and document blocks that admission and billing apply, so multimodal estimates rise to match what is charged.- Validation errors on
/v1/messagesnow name fields in Messages coordinates (messages[i].content[j]) instead of the Responses spelling. /v1/messageserror bodies now carryerror.request_id, matching theX-Request-Idheader, completing the 2026-07-15 error-identification contract on the Messages surface.- The Claude Code installer verifies the key with one authenticated request before storing it, reports incomplete setups honestly, and gains an uninstall command.
eb1-frontier-previewnow reports acontext_windowof400000in/v1/models, up from128000. The raised figure remains a floor the API honors on every request, with the same safety margins as before. The120000windows oneb1-preview,eb1-fast-preview, andeb1-efficient-previeware unchanged, as are the legacy request identifiers accepted for compatibility. Requests remain subject to the organization's per-minute token budget (request_exceeds_capacity, see 2026-07-19). Existing Codex setups pick up the new window on their next setup run.- Requests to preview models rejected purely for context size now return
400 invalid_request_errorwithcodecontext_length_exceeded, matching every other context-overflow rejection. Previously this one path reported the genericrequest_requirements_unsatisfied. That code is now reserved for requests whose input, tool, reasoning, or media requirements cannot be satisfied together for reasons beyond context size alone.
2026-07-26#
- Stream lifetimes are now documented per-effort time entitlements instead of one flat internal timeout. A stream that is actively working is never ended for taking long: streams end early only on a documented idle timeout (90 seconds without model activity; 120 seconds at
xhighand above) or on the wall-clock ceiling for the requested reasoning effort (5 minutes atnone/minimalup to 60 minutes atmax/ultra). Requests that do not set a reasoning effort resolve no lower than themediumrow (10 minutes);eb1-frontier-previewdefaults to themaxrow. Previously, long runs could be interrupted near 600 seconds even while the model was still working. - When a stream deadline fires, the run ends with one honest terminal instead of a spurious error: Responses streams carry
response.incompletewithincomplete_details.reasonofstream_idle_timeoutorstream_ceiling_timeout; Chat Completions reportsfinish_reasonlengthand Messages reportsstop_reasonmax_tokens. Tokens consumed before the stop are billed; the terminal event is truthful about why the run stopped. See Streaming.
2026-07-22#
- The discoverable model catalog is
eb1-preview,eb1-frontier-preview,eb1-fast-preview, andeb1-efficient-preview, superseding the naming contract published on 2026-07-20. Theeb1-preview-efficient,eb1-preview-fast, andeb1-preview-deltaidentifiers remain accepted on requests and in stored conversations with unchanged behavior and pricing, but no longer appear in/v1/models, Console menus, CLI listings, or Codex setup. Responses to requests that use one of those identifiers name the canonical id; responses toeb1-preview-deltarequests nameeb1-delta-preview, which remains callable but does not appear in discovery. - Invalid model-exclusion inputs now return the governed, non-retriable
400 invalid_request_errorenvelope withcodebad_request. Previously these caller-fixable requests could be serialized as a retriable502 upstream_error. Synchronous responses now carryx-should-retry: false; synchronous bodies and streaming error frames carryretryable: falsewith no retry horizon.
2026-07-20#
- Public discovery, Console, CLI, and Codex now use one four-model naming contract:
eb1-preview,eb1-preview-efficient,eb1-preview-fast, andeb1-preview-delta. Existing stored configurations using earlier preview spellings remain request-compatible, but new configuration and response identity use the current IDs. - Keiro 0.12.22 requests safe reasoning summaries for registered eb1 models and displays available segments while a response is in progress. These segments are terminal activity, not assistant answer text: they do not enter conversation history, copied code blocks, or piped stdout. Python callers can consume the same validated stream separately with
ModelsAPI.responses_stream(on_reasoning_summary=...)or its admin sibling. Requests to models outside the eb1 family receive no implicit summary setting.
2026-07-19#
- Responses usage now reports provider-supplied prompt-cache reads and writes in
input_tokens_details.cached_tokensandcache_write_tokens, instead of always reporting zero. Both are subsets ofinput_tokensand do not changetotal_tokens. The Console chat tester preserves those reported cache-read counts andoutput_tokens_details.reasoning_tokensin a compact Token details disclosure when those subsets are positive; required structural zeroes remain undisclosed because they do not prove provider provenance. It labels arithmetic totals and remainders as derived and does not fabricate system-prompt, history, user-message, or tool-schema buckets that the API does not separately report. - Published context windows now match the limit the API enforces end to end.
eb1-preview,eb1-efficient-preview, andeb1-fast-previewreport acontext_windowof120000in/v1/models, down from the previously published128000;eb1-frontier-previewis unchanged at128000. Requests between the two figures could previously be rejected with a context-overflow error despite sitting inside the published window; the published figure is now a floor the API honors on every request. - Requests whose selected model cannot satisfy every input, tool, reasoning, and context requirement now fail before dispatch with non-retriable HTTP 400 code
request_requirements_unsatisfied. - Requests whose token estimate exceeds a full minute of the organization's token-per-minute budget now return a terminal
400 invalid_request_errorwithcoderequest_exceeds_capacity, instead of a429rate limit. The old429carried aRetry-Afterheader even though no unchanged retry could ever succeed, trapping status-driven clients in an infinite retry loop. The new response carriesx-should-retry: false, no retry horizon, and nox-ratelimit-reset-*-tokensheader; the message anddetails.dimension: "token_budget_request"are unchanged. Reduce the input ormax_output_tokens, or raise the limit, and resend.
2026-07-18#
- Usage objects on OpenAI-format surfaces now itemize reasoning tokens and follow the standard arithmetic exactly. Chat Completions usage gains
completion_tokens_details(withreasoning_tokens), andtotal_tokensalways equalsprompt_tokens + completion_tokens, with reasoning counted insidecompletion_tokens. Previously, reasoning-heavy requests could report atotal_tokenslarger than the visible sum with no breakdown. - Responses usage now matches the standard
ResponseUsageschema:input_tokens,input_tokens_details.cached_tokens,output_tokens,output_tokens_details.reasoning_tokens, andtotal_tokens(= input_tokens + output_tokens). The former non-standard flatreasoning_tokenskey and theprompt_tokens/completion_tokensaliases are removed. Strict typed SDK clients that previously failed to validate usage now parse it; clients reading the flat keys must switch to the nested fields. /v1/messagesoutput_tokensnow includes reasoning tokens, matching the Anthropic convention that thinking is part of output.usagedetail objects reportcached_tokens: 0for now; prompt-cache accounting is not yet reflected in usage counts.
2026-07-17#
- Retired the
/v24bversioned endpoint path. It no longer differs from the current default deployment, so requests to/v24b/v1/*now return410 endpoint_retiredinstead of serving the current default under a versioned label. Use the default API (/v1). - The Keiro CLI no longer offers a
v24bendpoint preset.keiro endpoint v24b, saved v24b gateway URLs, and explicit v24b URLs surface the retirement guidance instead of binding to the default gateway.
2026-07-15#
- Missing pricing for an otherwise valid model now returns the governed, non-retriable
404 model_not_foundenvelope withx-should-retry: false. - Chat Completions stream error frames now nest a full
errorobject (code, type, message, retry signals,retryable,request_id, anddetailson limit denials) alongside the existing flat fields. OpenAI-compatible SDKs surface it as a typed error instead of failing to parse the frame. The flat fields are deprecated (removal is at least two releases out and gated on usage telemetry); Messages and Responses stream error frames gain the samedetailsobject on limit denials. /v1/messagesresponses now also carry arequest-idheader (an alias ofX-Request-Id) so Anthropic-compatible SDKs populate.request_id.- Responses that produced no output because reasoning consumed the entire completion budget now report
status: "incomplete"withincomplete_details.reason: "max_output_tokens"and awarningnaming the fix, instead of claiming success; Chat Completions reportfinish_reason: "length". Billed usage is unchanged and still reported. - Error messages no longer carry
[Error NNNN]/[Recovery: …]bracket furniture; recovery guidance appears as a plain sentence only when it applies to the specific failure. Message text remains non-contractual. - Corrected upstream authentication failures to a fixed
502withcodeupstream_auth_error. Previously an upstream401could pass through as your fault; SDKs raisedAuthenticationErrorand stopped retrying for a platform-side condition. Your API key is valid when you see this code. - Replaced the
401codeauthentication_error(which duplicatedtype) with three specific codes:missing_authorization,bearer_scheme_required, andinvalid_api_key(with a redacteddetails.key_hint). Code-matching clients keep working: the old code's value remains as the errortype. All401responses now carryWWW-Authenticate: Bearer. error.paramis now populated with the offending field name where known; previously documented as alwaysnull.- Documented every error code with per-code anchors, added
413and415to the status table, and removed the never-emitted408row. - Added retry-signal headers to error responses:
retry-after-ms(milliseconds, fractional precision) on retriable denials andx-should-retry: falseon denials an unchanged retry cannot clear. Deterministic denials also carry"retryable": falsein the error body. - Error responses now include
error.request_id, matching theX-Request-Idheader; stream error frames carry it on the Messages and Responses wires.
2026-07-10#
- Added an API reference index and dedicated guides for Messages, function tools, image input, API-key lifecycle, usage and billing, and Codex setup.
- Reworked Quickstart into an install-to-output workflow with one credential policy: saved Keiro credentials, interactive curl/Python secrets, and secret-file references for other runtimes.
- Reconciled API-key guidance with the console's create, staged-replacement, and delete/revoke workflow.
- Added contextual related-page paths throughout the documentation.
- Corrected the subprocessor description: authenticated docs are served by Keiro-operated services, while Netlify hosts the public website, early-access intake, and published status artifact.
2026-07-01#
- Documented idempotent requests, including the
Idempotency-Keyheader, theX-Idempotent-ReplayandX-Original-Request-Idreplay headers, and409 idempotency_key_conflictconflicts. - Documented the
409status code and clarified that the errorparamfield is alwaysnull. - Added a Responses streaming event taxonomy.
- Documented Netlify's hosting purpose for the public website, early-access intake, and published status artifact.
2026-06-25#
- Added shared Keiro Labs web-surface tokens to generated docs.
- Added skip links, active sidebar navigation, canonical URLs, Open Graph URLs, and table scrolling to the docs shell.
- Updated docs Markdown rendering for emphasis, blockquotes, h4-h6 headings, and in-list code fences.
- Updated rate-limit retry guidance to honor
Retry-After.
2026-06-15#
- Added initial paid beta public docs surface.
- Standardized runnable examples on one public base URL.
- Documented chat completions, responses, streaming, models, rate limits, errors, SDKs, support, and migration guidance.
- Kept local
keiro guiscoped to chat UX only.