For normal OpenAI setup, use a Platform API key. This facade does not resolve unsupported subscription onboarding; see OpenAI setup and subscription limits.
This opt-in, bounded Responses facade is for a separately isolated, owner-only OpenClaw Gateway or Codex runtime. It is not per-user security for a shared Gateway. Production Team must not receive these bindings or credentials. Shared agents must have no access to the private ingress credential, process, workspace, session namespace, or upstream credentials. Use a separate deployment and administrative trust boundary; a deployment operator can change its code or bindings and is necessarily trusted. Include owner-authenticated browser profiles and remote-node/tool capabilities in that boundary: shared agents must not be able to drive a browser carrying the owner's session or administer the private cell.
Nothing in this implementation provisions that isolation. Local synthetic tests
do not prove live upstream entitlement, client compatibility, owner-only
ingress, or OS/process isolation. In particular, /responses support does not
establish native Codex integration.
For a dedicated private Worker, use worker/private-entry.ts as its entrypoint
and bind only the two private secret-store objects below. This entrypoint exposes
no shared admin, public catalog, usage, or proxy routes. Disable automatic Worker
request logs and tracing for that deployment. The facade emits one constrained
server-side event for authenticated requests it rejects locally with HTTP 400:
{ predicate, request_bytes }. Predicates are fixed validator names and
request_bytes is the exact body byte count consumed, or null when rejection
precedes body reading. The event never uses Content-Length and contains no
request identifier, header, body, model, alias, URL, credential, exception, or
rejected field value. Hidden-route 404s, upstream failures and successful calls
emit no such event. Verify the actual deployed origin with the native client
before enabling a consumer. A local emulator does not establish upstream
acceptance of the deployed transport.
Two separate, owner-controlled secret-store object bindings are required. Each
implements get(): Promise<string> returning one JSON document. These are not
ordinary string environment credentials, POLICY_KV records, manifest values,
generic grants, or admin configuration. No generic admin read/mutation endpoint
exposes or changes them. Never place the upstream document in source, fixtures,
deployment vars, reports, or client configuration. The manifest compiler and
admin bundle have no private model entry.
PRIVATE_CODEX_POLICY has this exact shape (unknown fields are rejected):
{
"version": 1,
"enabled": true,
"alias": { "id": "codex-latest", "name": "Codex (Latest)" },
"auth": {
"mode": "access",
"issuer": "https://synthetic-owner.cloudflareaccess.com",
"audience": "SYNTHETIC-PRIVATE-APPLICATION-AUDIENCE",
"githubAccountId": 123456,
"identityProviderId": "SYNTHETIC-APPROVED-GITHUB-IDP"
}
}alias may also contain supportedReasoningEfforts, using the existing client
catalog field name. When supplied, it must be a nonempty array of 1–7 unique,
case-sensitive values from none, minimal, low, medium, high, xhigh,
and max. Null, empty, duplicate, unknown or oversized lists fail closed.
The approved list is preserved in authenticated private /models and /catalog
model rows only; it is not added to inference requests or public discovery.
An id/name-only alias remains valid and omits this descriptor. The facade never
infers reasoning from the alias, provider or upstream identifier, and does not
assume every private model supports reasoning.
Source the configured capabilities from the actual entitled model's metadata through trusted owner provisioning. Publish only its verified intersection with the supported public effort enum; do not guess, invent or relabel an unsupported upstream level. This is a capability descriptor, not entitlement or a native JSON ModelInfo artifact. The parent must continue supplying full alias-only native ModelInfo separately. The field does not advertise pricing, token limits, context capacity or full context support; those contracts are unchanged.
The example contains synthetic identity values. Replace them through the parent's
approved provisioning flow. The issuer must be a lowercase HTTPS
*.cloudflareaccess.com origin without a path. Audience and identity-provider ID
are exact, case-sensitive, non-whitespace ASCII strings of 1–256 characters.
githubAccountId must be a positive safe integer (at most 9007199254740991).
Both GitHub account and approved IdP pins are required. The earlier unshipped
subject-only configuration is rejected; there is no fallback.
The facade first uses the existing RSA Access JWT verifier for signature,
audience, issuer and time validation and requires the exact configured issuer.
Only then does it request that exact assertion's identity from the pinned
issuer's /cdn-cgi/access/get-identity, using Cookie: CF_Authorization=<assertion>.
It never chooses a destination from unverified claims, follows redirects, or
forwards caller cookies. The lookup uses cache: "no-store", has no application
cache, and has no stale-identity or management-API fallback. HTTP failure,
malformed/oversized data, unsupported encoding, timeout or cancellation denies
access with generic not-found before private upstream secret resolution.
The response must contain idp.type: "github", the exact configured idp.id,
and a numeric positive safe-integer id matching githubAccountId. Its email
must match the verified JWT's email after trimming and lowercasing; both are
nonempty strings limited to 1024 characters. Email only correlates the lookup
with the assertion; it does not authorize. An unchanged email or Access subject
cannot authorize a different GitHub account. A changed email or subject can be
accepted when token/identity correlate and the GitHub account and IdP pins match.
Names, login handles, groups, admin roles, local sessions and caller identity
headers never substitute for those pins.
Cloudflare documents Access sub
as unique to an email address within a Cloudflare account, not as an immutable
GitHub account identifier. The old subject-only path proved only its configured
Access subject; no email-transfer exploit is asserted. The replacement binds
authorization to the numeric GitHub identity and approved IdP reported for the
verified assertion. Synthetic signed-JWT tests prove the local enforcement, not
Cloudflare's real GitHub-specific response shape: the parent must prove that
shape using a real human assertion before enabling Access mode.
Policy and token validity are checked again after awaited lookup/binding work;
inference repeats verification and identity lookup after upload, then rechecks
policy and the fixed upstream binding before egress. Each lookup shares a
ten-second deadline with JWT verification and accepts at most 64 KiB of UTF-8
JSON. Cancellation propagates through fetch and body reads. The verifier's
existing clock tolerances remain (30 seconds for nbf, 300 for iat); expiration
must remain in the future. No token or identity body enters logs or discovery.
Disable the private policy to revoke subsequent requests. Generic user/admin policy changes do not revoke this independent authority. A token-specific Cloudflare lookup is not proof of an active GitHub browser session, an immediate GitHub revocation check, or ongoing delegated human authority. Cloudflare's identity/revocation propagation and the secret store's consistency remain external limits. Requests already streaming are not continuously reauthorized or terminated by later policy changes. Owner-only ingress and process/browser isolation, real identity proof, and the other deployment gates remain required.
Alternatively, replace auth with exactly:
{
"mode": "workload",
"credentialSha256": "LOWERCASE-SHA256-HEX-DIGEST"
}The digest is exactly 64 lowercase hex characters. The separately provisioned
credential has the form private-workload- followed by 32–128 URL-safe ASCII
characters (A–Z, a–z, 0–9, _, -). Provision at least 256 random bits;
do not derive it from a user/session or reuse any admin, proxy, or upstream secret.
Only its SHA-256 digest is stored in policy. Requests use the exact header
Authorization: Bearer <private-workload-credential>. This bearer authenticates
the dedicated workload, not the human, is transferable if stolen, and is not
delegated human authority. Owner-only ingress and OS/process isolation are
mandatory. There is no signature/TTL/attribution scheme claiming otherwise.
These are the only two supported authentication modes and are mutually exclusive. Workload mode rejects Access JWT authentication; Access mode rejects Authorization. Conflicting authentication headers are rejected even when their values are empty. Alternate API-key headers, proxy auth, and Access service-token headers are rejected. Cookies and caller identity headers cannot authenticate. Configuration and authentication are read on each request, and rechecked after the request upload immediately before egress.
OAuth credentials must stay broker-only. Neither native Codex nor OpenClaw,
their tools, nor other client processes may receive the upstream token, account
binding, or access to the broker's secret store, files or process memory. Giving
a tool-bearing client OAuth would let it bypass the facade and query the raw
upstream catalogue directly. Inference workloads receive only the independent
opaque workload credential, which cannot authenticate to the upstream provider. The facade
serves only alias-safe discovery; it offers no raw catalogue, OAuth, arbitrary
proxy or account-selection endpoint. Caller ChatGPT-Account-ID and custom
account headers are rejected in both modes. Only the broker constructs the
upstream account header from its fixed authenticated binding.
PRIVATE_CODEX_UPSTREAM explicitly selects one credential and transport. The
original subscription shape remains supported when transport is absent:
| Field | Contract |
|---|---|
version |
Number 1 |
target |
Runtime-only upstream binding; 8–128 ASCII letters/digits/./_/-, beginning with a letter/digit |
fallbackTarget |
Optional, distinct target with the same syntax; at most one alternative, never exposed in discovery |
accountId |
Exact subscription account; 8–128 ASCII letters/digits/_/- |
accessToken |
Separately held subscription access token; 16–8192 ASCII letters/digits/./_/~/- |
expiresAt |
Integer Unix milliseconds, at least 30 seconds in the future |
For OpenAI API access, the document has exactly version: 1,
transport: "openai-api", target, and apiKey, plus an optional
fallbackTarget. Target syntax is unchanged. The API key is 16–8192 ASCII
letters/digits/./_/~/-; subscription account, token, and expiry fields
are rejected in this mode. The destination is fixed to
https://api.openai.com/v1/responses, with no subscription account header.
The API transport preserves max_output_tokens and genuine native client,
Lite, review, and safety facts. Verify API entitlement and native compatibility
before provisioning it. API usage is billed normally by the provider; this
private facade does not write the shared usage ledger.
The alias ID is 3–64 lowercase ASCII letters/digits/hyphens, beginning with a letter. Its display name is 1–80 printable ASCII characters. Use the safe values shown above. Neither may contain the target, account ID, or upstream credential. Both binding documents are limited to 16 KiB of text. Missing, disabled, malformed, expired, inaccessible, or mid-request changed configuration fails closed.
The upstream binding is read only after authentication, including on private discovery. The adapter sends exactly the configured credential to the selected transport's fixed Responses URL. Subscription mode also sends its fixed account. No caller can change the provider, account, origin, or configured targets. There are no redirects, alternate accounts, cross-transport fallbacks, generic grant lookups, Fusion paths, or arbitrary-model/native routing inside this facade.
When fallbackTarget is configured, the broker may make one additional call on
the same fixed transport and credential after an explicit HTTP availability failure:
404 model_not_found, 429 rate_limit_exceeded, or a 502/503/504 carrying
server_error, service_unavailable, overloaded_error, or timeout. Unknown
errors, authentication, safety, entitlement and exhausted-quota denials are
terminal. Transport exceptions and any response stream that has begun are
terminal too. Requests with previous_response_id or x-codex-turn-state stay
on the target that issued their state and cannot fail over again.
With fallback configured, typed response IDs and turn-state headers carry an opaque broker route envelope. An authenticated encrypted slot binds them to the current policy, target mapping, transport, account, and upstream credential. It contains no model name. The broker restores the original upstream values on the next call; it does not manufacture upstream signatures or attestations. Unwrapped legacy state remains primary-only, conflicting origins and tampering fail closed, and credential or routing rotation invalidates wrapped state. Clients must restart from full input after such a rotation. Without fallback, the existing opaque values remain unchanged.
Typed JSON and SSE turn-state headers preserve their original casing and scalar or singleton-array shape. Each accepted form carries the same continuation envelope, so subsequent turns remain on the issuing target.
Before the second call, the broker revalidates the caller and both complete bindings. Revocation or rotation stops the request. Both attempts share the existing deadline, preserve the request's genuine client and safety facts, and return only the same alias. Both configured identities remain sensitive on either attempt; model headers and safety selectors must match the selected target. Provisioning must verify entitlement and compatible native capabilities for both targets. The fallback does not invent compatibility or bypass upstream requirements.
For subscription mode, automatic OAuth refresh is intentionally absent. The existing shared refresh helper writes shared grant state and does not provide this boundary's required revocation/rotation transaction. The parent must provide an owner-only lifecycle that atomically replaces this private token/account/expiry document, or accept fail-closed expiry. Token/account correspondence and subscription eligibility still require trusted provisioning and upstream proof. No refresh tokens are accepted here. Binding read freshness depends on the deployed secret store; there is no extra application cache or promise of instantaneous revocation of already transmitted requests/streams.
Broker token rotation does not require changing the independent client workload credential or exposing the new token to clients. Changes during a request's upload still fail closed. Binding expiry must reflect the real token lifetime; provider expiry/revocation denials remain denials. API keys have no locally invented expiry; their provider revocation and authorization denials are terminal.
| Method | Exact path | Result |
|---|---|---|
| GET | /private/v1/models |
One OpenAI-style model: safe ID, display_name, llm.responses capability |
| GET | /private/v1/catalog |
Client catalog v1 with a private Responses provider; model upstream equals the alias because the catalog contract requires it |
| POST | /private/v1/responses |
Bounded JSON or SSE Responses transport |
The catalog intentionally retains the existing V1 consumer shape:
nativeBaseUrl: "/v1/native/private", route path: "/v1/responses", and
openaiCompatible: true, with only llm.responses advertised. The native base
is a catalog schema field, not an enabled transport. Only the private unified
Responses endpoint executes; private and public native/proxy routes do not gain
access to this binding.
OpenClaw reads supportedReasoningEfforts from each catalog model row to enable
reasoning and construct its compatible effort mapping without depending on an
opaque alias's spelling. Configure this descriptor for a reasoning-capable model;
omitting it can change the consumer's request semantics, including whether its
Responses system prompt uses a developer role. The descriptor does not change
review requirements, provenance, sandbox settings or the private auth boundary.
Unauthorized callers receive the same generic 404 body and private no-store headers as unknown private routes. No private alias appears in public discovery, service indexes, provider snapshots, routes, or generic admin metadata. No CORS or public correlation/header reflection is added to private responses.
Only the configured alias is accepted in the top-level model. store: false
is required, and background execution is rejected. The adapter rewrites model
only when constructing the upstream body. Input, tool schemas, instructions,
reasoning, encrypted content, and accepted client metadata are not rewritten.
Top-level request fields are limited to model, input, instructions, stream,
store, tools, tool_choice, parallel_tool_calls, reasoning, text,
include, max_output_tokens, temperature, top_p, truncation, metadata,
previous_response_id, prompt_cache_key, prompt_cache_retention,
safety_identifier, service_tier, background (absent or false),
client_metadata, stream_options, and access_programs.
Unknown top-level fields fail closed. Nested tool schemas/data and metadata are
opaque input, never routing configuration.
The fixed subscription adapter accepts optional max_output_tokens only as a
positive safe integer (1–9,007,199,254,740,991) for client compatibility. It omits
only that top-level field when building the upstream body, without mutating
the original request or nested data. The subscription backend does not support
this generation option. All other accepted fields, including service_tier,
review/approval metadata, attestation and genuine client facts, remain unchanged.
Requests without the field retain their existing semantics apart from the
alias and routing-hint translation. No client configuration knob is required.
After adapting an authenticated inference request that supplied a valid value,
the facade generates x-clawrouter-ignored-parameters: max_output_tokens on its
JSON/SSE response, including provider denials and transport failures. The header
contains only the field name, never the caller's value. It is absent for discovery,
unauthorized or locally invalid requests, and requests that did not supply the
option. Caller/upstream copies of that header are not trusted or reflected.
The disclosure remains subject to private identity containment; if it cannot be
emitted safely, the request fails without leaking the identity.
This is not an enforced output limit or budget. Subscription generation is provider-controlled; using this endpoint cannot promise a caller token cap. The existing byte, queue and time limits still apply, and private accounting remains deliberately unmetered. Native subscription transports already omit this option, but that does not justify stripping their broader legacy parameter list here or claiming that a discarded limit was honored.
The additional body fields follow the inspected native Codex HTTP wire contract.
client_metadata is a bounded string map containing only x-codex-installation-id,
session_id, thread_id, turn_id, parent_turn_id, root_turn_id,
x-codex-window-id, x-codex-parent-thread-id, x-openai-subagent, and
x-codex-turn-metadata. The last field is a JSON object encoded as a string;
its sandbox, review, workspace and tool-inventory facts remain unchanged.
stream_options permits exactly reasoning_summary_delivery: "sequential_cutoff"
on streaming requests. access_programs permits exactly one cyber wire token
(1–64 lowercase letters/digits/underscores, starting with a letter). It is an
upstream access selection, not entitlement granted by this facade. These optional
fields may be absent or null. No program, review flag, attestation, or fallback is
fabricated. Unknown fields and malformed values are rejected.
Forwarded headers are limited to genuine caller version, session-id, thread-id,
session_id, x-client-request-id, user-agent, originator, openai-beta,
x-openai-internal-codex-responses-lite, x-codex-beta-features,
x-codex-turn-state, x-codex-turn-metadata, x-codex-parent-thread-id,
x-codex-window-id, x-oai-attestation, x-openai-subagent,
x-openai-memgen-request, x-responsesapi-include-timing-metrics, traceparent,
and tracestate. Lite negotiation and attestation are forwarded only when
present; OpenClaw must retain its truthful originator and user agent. Relaying
an attestation envelope neither verifies it nor changes the upstream's authority
to reject it. Caller identity/session facts do not participate in facade auth.
The separately supported x-codex-routing-hint must be exactly model=<alias>
or model=<alias>;tier=<tier>. Its optional tier must match body service_tier.
After authorization and the final config recheck, only its model is translated
to the runtime target at egress. No arbitrary model, provider, account or URL
selector passes. Unknown semantic Codex/review/approval/attestation headers still
fail closed. The opaque turn-state affinity token is relayed unchanged only
after bounded inspection of literal, JSON, percent-encoded and base64/JWT text
for sensitive values and unknown structured model selectors; it is never
rewritten into invalid signed/ciphertext state.
These contracts were checked against native core/src/client.rs,
core/src/responses_metadata.rs, and codex-api/src/{common.rs,sse/responses.rs, rate_limits.rs,safety_buffering.rs}. Additional protocol requires source review.
Queries, encoded route spellings, trailing slashes, alternate methods,
compression, non-UTF-8 content, the legacy unary /responses/compact endpoint,
websocket, upload, usage, and every other endpoint are unsupported. Upstream
redirects and errors outside the bounded availability fallback do not trigger
another provider call. At ingress, enforce rejection of raw dot segments/backslashes
before URL normalization: the Worker cannot recover path spellings already
normalized by the HTTP runtime. Normalized routes never select an alternative
private endpoint/provider/target.
For the separately isolated OpenClaw consumer, the parent's base URL is
https://PRIVATE-ORIGIN/private (plugin appends /v1). For a Codex consumer it is
https://PRIVATE-ORIGIN/private/v1. The catalog alone does not prove that a consumer
honors its Responses-only capabilities, display name, store: false, or lack of usage.
The consumer needs its full, alias-safe native model metadata, including genuine
Lite, compaction, and safety requirements; a reduced facade discovery row is not
a substitute. Configured on-request/manual review with a workspace-write sandbox
is a valid distinct control mode when the selected model does not require
automatic review. Omitted optional auto-review fields are not a requirement to
invent or enable automatic review. This does not claim Guardian equivalence and
does not change trusted-endpoint checks for automatic review.
The native Codex CLI uses its built-in OpenAI provider with the broker workload
credential supplied as an API-key credential and full alias-only model metadata.
It does not receive OAuth or acquire a native ChatGPT account identity through
the facade. Genuine client metadata, originator, version, review and sandbox
facts are retained; OpenClaw must not impersonate Codex. This configured mode
does not claim automatic Guardian or subscription-auth/refresh parity. Native
Codex and OpenClaw compatibility still require the parent's private proof for
their respective request shapes and configured control modes. Upstream rejection
is not a reason to spoof identity or bypass restrictions.
Native remote compaction v2 is distinct from the unsupported unary endpoint:
it sends compaction_trigger input and consumes a completed compaction item on
the ordinary Responses stream. The default/manual v2 path in Codex
0.150.0-alpha.13, followed by a tool turn, has been live-verified in the isolated
workload-authenticated profile described above. Direct OpenClaw manual compaction
and its subsequent tool turn were also verified. This does not establish automatic
threshold behavior, full-context capacity, other client versions, or auxiliary
endpoint support. Required additional or safety protocol remains a deployment
blocker until implemented and verified; do not bypass it or disable requirements.
Response headers are generated locally: content type, private no-store,
nosniff, retention off, and accounting private-unmetered. Cookies, locations,
request IDs and unknown transport headers do not pass through. Known Codex quota
families, credit/promo/limit labels, and model catalog etags are stripped without
rejecting success; labels may name private models. codex.rate_limits SSE events
are also omitted because this facade does not expose quota reporting.
The source-defined optional timing observation is likewise stripped; accepting
that observation does not enable the unsupported WebSocket endpoint.
Discarded quota/timing observations may not carry response or safety envelopes,
or retained semantic headers. Those combinations fail closed rather than hiding
model identity, safety or attestation protocol. Ordinary observations, including
headers containing only discarded quota/transport data, remain discardable.
The exact OpenAI-Model/x-openai-model identity maps to the alias only when its
value equals the configured target or alias; a different model fails closed.
The same projection applies to top-level SSE headers and response.headers.
Safe x-codex-turn-state affinity and x-reasoning-included presence are
preserved. The known x-codex-safety-buffering-enabled flag is preserved,
including false; the faster-model header and structured retry_model may only
refer to the expected target/alias and are projected to the alias. Null retry
recommendations remain null. An unknown or different safety reroute fails,
rather than being relabeled as primary-model success. Moderation and verification
metadata are preserved, never manufactured. Unknown semantic safety/attestation
response headers still cause sanitized failure.
HTTP provider denials keep their 4xx status and use private_upstream_error,
without the provider's body. In particular, an upstream HTTP 400 is distinguishable
from a local 400 invalid_request; local request rejection is not evidence of
upstream incompatibility. Transport/server/protocol errors
return generic failure; late SSE failures emit a generic error event and cancel
upstream. Source-recognized policy/quota/context denial codes instead retain a
sanitized response.failed envelope and their exact allowlisted code so native
clients do not lose denial classification. Messages and arbitrary error details
never pass through. Refusal content and incomplete status remain intact when safe.
Reporting model projection belongs only to the JSON Response root model and
SSE event response.model. These reporting fields map to the alias even when
the backend reports a name different from the requested target. Native Codex's
ResponsesStreamEvent::response_model() reads only response.headers and event
headers; its explicit process_sse_ignores_response_model_field_in_payload
test confirms that body response.model does not produce a ServerModel event.
Reporting projection therefore does not authorize or conceal a model-header
reroute. The configured target remains the separate, immutable authority for
all model headers and typed safety selectors.
The shared JSON/SSE projection owner learns at most one additional reporting name per response, before inspecting sibling data and before releasing any body frame or accumulating logical-delta history. The name must be 1–128 printable ASCII characters and not blank. It becomes another sensitive value alongside the configured target, account ID and token, including in encoded tool JSON, opaque affinity and split logical deltas. Repeating it, the target or the alias is allowed; changing it or first declaring a new name after output/history fails closed. A rejected additional candidate is retained only while sanitizing the terminal failure, not added to routing authority. Matcher tables grow only before history exists; no held prefix is discarded to accommodate a new name. SSE primes one bounded output chunk and reinspects HTTP headers against the learned name before releasing them. This may delay the initial HTTP response; existing limits, transport deadline and cancellation still apply. There is no promise of identifying an undeclared reporting name retroactively.
Only typed protocol envelopes interpret headers, Response error, and safety
selectors: SSE safety_buffering, or response.metadata with metadata
type: "safety_buffering". Tool schemas, arguments, code, user objects and other
arbitrary data may contain properties named model, error, headers or
retry_model; their names alone never trigger projection or rejection.
All retained decoded strings and keys are still inspected for known sensitive
values. Tool argument JSON is also inspected after decoding. Arbitrary text and
encrypted/tool data are never redacted into a different successful payload:
an unrepresentable leak is a sanitized failure. If even the fixed local failure
text contains a learned name, the facade ends without that text rather than
echoing it; it never emits a successful completion in that case.
For supported text/refusal/reasoning deltas, the stream holds events containing
a possible sensitive suffix until that logical stream disambiguates it. This
survives network chunks, event boundaries and interleaving, and also checks the
combined text consumed by native Codex's item-independent text-delta event.
Source-supported missing output indexes and anonymous text/summary events work
with conservative identity tracking; ambiguous identity changes still fail.
Function argument events are held until a matching done event or completed
output item supplies identical, valid JSON. Custom-tool input deltas use the
same bounded holdback but preserve freeform input, rather than requiring JSON.
Standalone tool done events are inspected without inventing earlier deltas.
Encrypted tool/reasoning data is preserved. This can delay tools. A bounded queue preserves original
event order and metadata. Completed/incomplete events are held until [DONE]
or clean EOF; source-supported completion objects need not contain a status
field, but an explicit conflicting status fails. Malformed/truncated streams
fail. response.metadata and codex.response.metadata remain supported.
Event types are explicitly allowlisted; an unknown safety/protocol event cannot
be passed through into an apparently successful stream that ignores it.
Native SSE may omit Content-Type; a supplied Content-Type must still identify
UTF-8 SSE and every frame is validated. No unbounded buffering is used.
Request JSON accepts up to 8 MiB of UTF-8 bytes, sharing the public JSON intake limit so full-history requests are not restricted to 1 MiB. The limit includes all fields and JSON overhead; it does not establish a model's token capacity.
Output limits: 4 MiB JSON response, 256 KiB SSE frame, 1 MiB holdback or individual network chunk, 1024 held events, 128 logical streams/items, 64 MiB total SSE bytes, 48 JSON nesting levels, and 50,000 inspected nodes. Request upload has a 30-second deadline; each Access verification plus identity lookup has a shared ten-second deadline and a 64 KiB identity response limit; upstream transport has a ten-minute deadline and propagates client cancellation. Unsupported delta families or missing/changed unresolvable logical identities fail closed. Header values remain limited to 8 KiB each and 64 KiB total; response headers also have a 128-field limit. Client metadata has at most 32 fields, 8 KiB ordinary strings, a 256 KiB turn metadata string, and 32 levels/10,000 nodes within decoded turn metadata. Oversize or unsupported content is never silently truncated into success.
This detects exact decoded values and supported logical delta reconstruction; it is not a guarantee against arbitrary encodings, ciphertext, semantic model identification, or a malicious upstream's covert channels. Operators must also disable external request/body/header tracing and restrict logs, crash dumps, secret-store access, and the upstream runtime itself.
The private facade never writes to CONTENT_ARCHIVE, generic usage queues,
budget ledgers, admin state, or application logs. There is no billing, budget
enforcement, quota reporting, or usage persistence in this scope. Numeric usage
may remain in a safe provider response, but is not a billing calculation. Generic
policy changes cannot enable retention here. The alias facade does not isolate
the upstream account's own sessions; use only the separately owned account and
execution cell, with no shared session namespace.