@oh-my-pi/pi-ai 17.1.0 → 17.1.2

package/CHANGELOG.md

@@ -2,9 +2,44 @@
 
 ## [Unreleased]
 
+## [17.1.2] - 2026-07-24
+
+### Added
+
+- Added `GET /v1/usage/history` to the auth broker (recorded usage-limit snapshots with `sinceMs`/`provider` filters) and `AuthBrokerClient.fetchUsageHistory` — in broker deployments the broker host performs every upstream usage fetch, so its durable history is the only complete utilization record
+- Added per-client burn tracking to the auth broker: clients batch observed request usage per (provider, model) and flush it to `POST /v1/usage/observed` every 10 seconds (install id as client key, hostname as display name); the broker persists 5-minute buckets in `client_usage`/`clients` and serves aggregates from `GET /v1/usage/clients`. Brokers without the endpoint disable reporting for the process lifetime
+
+### Changed
+
+- Renamed the Z.AI feature quota row to `ZAI Zread Quota` (tier/id slug `zread`), replacing the 74-char `ZAI Web Search / Reader / Zread Quota (web-search-reader-zread)` title that wrapped `omp usage` rows
+
+### Fixed
+
+- Fixed every Claude (`anthropic-messages`) model on the `opencode-zen` provider failing with `401 Missing API key`: the gateway requires `x-api-key`, so `opencode-zen` now uses X-Api-Key auth like `opencode-go`/`umans` instead of bearer-only, and no longer sends the `context_management` field its Anthropic proxy rejects on thinking requests ([#6510](https://github.com/can1357/oh-my-pi/issues/6510)).
+- Fixed Anthropic native server-tool blocks being dropped from persisted assistant turns, preserving signed web-search continuations in their original response order ([#6495](https://github.com/can1357/oh-my-pi/issues/6495))
+
+## [17.1.1] - 2026-07-24
+
+### Added
+
+- Added `setCodexAttestationProvider` API for injecting `x-oai-attestation` headers in ChatGPT-OAuth Codex requests
+- Added OAuth account session pinning and active status tracking in storage
+- Added OpenAI Responses native computer-use transport, including batched actions and exact `computer_call`/`computer_call_output` replay with pending/acknowledged safety checks and `image_url`/`file_id` output references. Models without native support receive the same action surface as a regular function tool; provider-specific tool-choice forcing is used where supported.
+- Added `PI_CODEX_RESPONSES_LITE` to override the catalog-selected Codex Responses transport for diagnostics (`1`/`true` forces Lite; `0`/`false` forces the standard body).
+- Added caller-owned `cachedContent` on `google-generative-ai` and `google-vertex` GenerateContent options: pass an opaque cache resource name through the shared builder (blank values rejected); no create/refresh/delete lifecycle and no guessed model/project/location validation; existing `cachedContentTokenCount` → `Usage.cacheRead` normalization is unchanged.
+- Added Anthropic extra-usage reporting across `omp usage`, interactive `/usage`, and ACP `/usage`: the OAuth usage endpoint's authoritative `spend` payload (or legacy `extra_usage` fallback when absent) is normalized into a `Claude Extra Usage` USD row; capped accounts show limit/remaining/fractions and status, while uncapped spend exposes only its absolute used amount—rendered as `$… used` in CLI/TUI and `123.45 usd used` in ACP—without a fabricated cap, percentage, or status. ([#5575](https://github.com/can1357/oh-my-pi/issues/5575))
+- Added process-scoped OAuth account pools for trusted auth-broker clients via `OMP_AUTH_BROKER_ACCOUNT_POOL_FILE`, consistently filtering snapshots, streaming updates, refreshes, and usage reports to selected OAuth identities while leaving API-key credentials and the shared encrypted snapshot cache unrestricted.
+- Added opt-in Vercel AI Gateway automatic prompt caching for OpenAI Chat Completions while preserving `only` and `order` routing preferences.
+- Added Vercel AI Gateway Responses cache anchors and cache lifetimes, emitted only with automatic caching.
+- Added opt-in OpenAI GPT-5.6 explicit prompt-cache controls for Responses and Chat Completions. Existing requests remain implicit; the policy marks at most one existing stable-history block and is rejected locally on unsupported explicit routes.
+- Forwarded `statefulResponses` through `streamSimple`, so diagnostic callers can explicitly disable OpenAI Responses `previous_response_id` chaining.
+- Added native QwenCloud Token Plan API-key login, model discovery, and an optional interactive console-Cookie prompt for 5-hour and 7-day quota reporting ([#6151](https://github.com/can1357/oh-my-pi/issues/6151)).
+- Added model-scoped usage health and same-provider reselection for native coding-plan credential pools, preserving OAuth/login-pool precedence, scoped broker blocks, sibling rotation state, and conservative unknown-account handling while excluding ordinary configured API keys ([#5018](https://github.com/can1357/oh-my-pi/issues/5018)).
+
 ### Fixed
 
 - Fixed stateful OpenAI Responses explicit cache breakpoints being restored onto edited historical messages, ensuring full replays recompute the latest stable cache boundary.
+- Fixed ChatGPT Codex standard and Lite transports rejecting or hiding native computer-use payloads by unrolling the tool definition, forced choice, `computer_call`, and `computer_call_output` into ordinary function-tool forms.
 
 ## [17.1.0] - 2026-07-24
 

package/dist/types/auth-broker/client.d.ts

@@ -1,5 +1,5 @@
 import type { AuthCredential } from "../auth-storage.js";
-import type { CredentialBlockRequest, CredentialBlockResponse, CredentialBlocksDeleteResponse, CredentialDisableResponse, CredentialRefreshResponse, CredentialUploadResponse, HealthzResponse, SnapshotResponse, SnapshotStreamEvent, UsageResponse, UsageStaleResponse } from "./types.js";
+import type { ClientUsageReportRequest, ClientUsageReportResponse, ClientUsageSummaryResponse, CredentialBlockRequest, CredentialBlockResponse, CredentialBlocksDeleteResponse, CredentialDisableResponse, CredentialRefreshResponse, CredentialUploadResponse, HealthzResponse, SnapshotResponse, SnapshotStreamEvent, UsageHistoryResponse, UsageResponse, UsageStaleResponse } from "./types.js";
 export interface AuthBrokerClientOptions {
     /** Base URL (e.g. `https://broker.tailnet:8765`). Trailing slashes are trimmed. */
     url: string;
@@ -60,6 +60,17 @@ export declare class AuthBrokerClient {
         signal?: AbortSignal;
     }): AsyncGenerator<SnapshotStreamEvent>;
     fetchUsage(signal?: AbortSignal): Promise<UsageResponse>;
+    /** Recorded usage-limit snapshots from the broker host, oldest first. */
+    fetchUsageHistory(query?: {
+        sinceMs?: number;
+        provider?: string;
+    }, signal?: AbortSignal): Promise<UsageHistoryResponse>;
+    /** Report this client's batched observed request usage for per-install burn tracking. */
+    reportClientUsage(report: ClientUsageReportRequest, signal?: AbortSignal): Promise<ClientUsageReportResponse>;
+    /** Per-client token burn aggregates recorded by the broker host. */
+    fetchClientUsageSummary(query?: {
+        sinceMs?: number;
+    }, signal?: AbortSignal): Promise<ClientUsageSummaryResponse>;
     notifyUsageStale(signal?: AbortSignal): Promise<UsageStaleResponse>;
     refreshCredential(id: number, signal?: AbortSignal): Promise<CredentialRefreshResponse>;
     disableCredential(id: number, cause: string, signal?: AbortSignal): Promise<CredentialDisableResponse>;

package/dist/types/auth-broker/remote-store.d.ts

@@ -1,7 +1,7 @@
 import { type AuthCredential, type AuthCredentialStore, type OAuthCredential, type StoredAuthCredential, type StoredCredentialBlock } from "../auth-storage.js";
 import type { OAuthCredentials } from "../registry/oauth/types.js";
 import type { Provider } from "../types.js";
-import type { UsageReport } from "../usage.js";
+import type { ObservedUsageEntry, UsageReport } from "../usage.js";
 import { type AuthBrokerClient } from "./client.js";
 import type { SnapshotResponse } from "./types.js";
 /**
@@ -33,6 +33,8 @@ export interface RemoteAuthCredentialStoreOptions {
      * routing policy, not broker authorization.
      */
     accountPool?: AuthBrokerAccountPool;
+    /** Flush cadence for batched observed-usage reports. Default 10s. */
+    observedUsageFlushMs?: number;
 }
 export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     #private;
@@ -120,5 +122,12 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
      */
     getUsageReport(provider: Provider, credential: OAuthCredential, signal?: AbortSignal): Promise<UsageReport | null>;
     ingestUsageReport(provider: Provider, credential: OAuthCredential, report: UsageReport): boolean;
+    /**
+     * Fold locally observed request usage into the pending report and schedule
+     * a flush. One `POST /v1/usage/observed` at most per flush interval; on
+     * failure the batch is retained and retried with the next flush. A 404
+     * (pre-endpoint broker) disables reporting for the life of this store.
+     */
+    recordObservedUsage(entries: ObservedUsageEntry[]): void;
     close(): void;
 }

package/dist/types/auth-broker/types.d.ts

@@ -6,7 +6,7 @@
  * credential expires or a 401 surfaces on a supposedly-fresh credential.
  */
 import type { AuthCredential, AuthCredentialSnapshot, AuthCredentialSnapshotEntry, StoredCredentialBlock } from "../auth-storage.js";
-import type { UsageReport } from "../usage.js";
+import type { ClientUsageClientSummary, ClientUsageReport, UsageHistoryEntry, UsageReport } from "../usage.js";
 /** GET /v1/healthz response body. */
 export interface HealthzResponse {
     ok: boolean;
@@ -34,6 +34,26 @@ export interface UsageResponse {
     generatedAt: number;
     reports: UsageReport[];
 }
+/**
+ * GET /v1/usage/history response body. Entries come from the broker host's
+ * durable `usage_history` — the broker performs every upstream usage fetch in
+ * broker deployments, so this is the only complete utilization record.
+ */
+export interface UsageHistoryResponse {
+    generatedAt: number;
+    entries: UsageHistoryEntry[];
+}
+/** POST /v1/usage/observed request body — one client's batched observed usage. */
+export type ClientUsageReportRequest = ClientUsageReport;
+/** POST /v1/usage/observed response body. */
+export interface ClientUsageReportResponse {
+    ok: boolean;
+}
+/** GET /v1/usage/clients response body — per-client token burn aggregates. */
+export interface ClientUsageSummaryResponse {
+    generatedAt: number;
+    clients: ClientUsageClientSummary[];
+}
 /** POST /v1/credential/:id/refresh response body. */
 export interface CredentialRefreshResponse {
     entry: AuthCredentialSnapshotEntry;

package/dist/types/auth-broker/wire-schemas.d.ts

@@ -418,6 +418,61 @@ export declare const usageResponseSchema: import("arktype/internal/variants/obje
         raw?: unknown;
     }[];
 }, {}>;
+/** Broker `/v1/usage/history` response — recorded usage-limit snapshots, oldest first. */
+export declare const usageHistoryResponseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    generatedAt: number;
+    entries: {
+        recordedAt: number;
+        provider: string;
+        accountKey: string;
+        email?: string | undefined;
+        accountId?: string | undefined;
+        limitId: string;
+        label: string;
+        windowLabel?: string | undefined;
+        usedFraction?: number | undefined;
+        status?: "exhausted" | "ok" | "unknown" | "warning" | undefined;
+        resetsAt?: number | undefined;
+    }[];
+}, {}>;
+/** Broker `POST /v1/usage/observed` request — one client's batched observed usage. */
+export declare const clientUsageReportRequestSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    installId: string;
+    hostname?: string | undefined;
+    entries: {
+        at: number;
+        provider: string;
+        model: string;
+        requests: number;
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+        costUsd: number;
+    }[];
+}, {}>;
+export declare const clientUsageReportResponseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    ok: boolean;
+}, {}>;
+/** Broker `GET /v1/usage/clients` response — per-client token burn aggregates. */
+export declare const clientUsageSummaryResponseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    generatedAt: number;
+    clients: {
+        installId: string;
+        hostname?: string | undefined;
+        firstSeen: number;
+        lastSeen: number;
+        providers: {
+            provider: string;
+            requests: number;
+            inputTokens: number;
+            outputTokens: number;
+            cacheReadTokens: number;
+            cacheWriteTokens: number;
+            costUsd: number;
+        }[];
+    }[];
+}, {}>;
 export declare const credentialRefreshResponseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     entry: {
         id: number;

package/dist/types/auth-gateway/types.d.ts

@@ -1,5 +1,5 @@
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
-import type { AssistantMessage, AssistantMessageEventStream, CacheRetention, Context, ServiceTier, TokenTaskBudget } from "../types.js";
+import type { AssistantMessage, AssistantMessageEventStream, CacheRetention, Context, OpenAIResponseInclude, ServiceTier, TokenTaskBudget } from "../types.js";
 /**
  * Wire types for the omp auth-gateway.
  *
@@ -14,6 +14,8 @@ import type { AssistantMessage, AssistantMessageEventStream, CacheRetention, Con
 export declare const DEFAULT_AUTH_GATEWAY_BIND = "127.0.0.1:4000";
 export type AuthGatewayToolChoice = "auto" | "none" | "required" | {
     name: string;
+} | {
+    type: "computer";
 };
 export interface AuthGatewayParsedRequestOptions {
     maxOutputTokens?: number;
@@ -39,6 +41,8 @@ export interface AuthGatewayParsedRequestOptions {
     toolChoice?: AuthGatewayToolChoice;
     /** OpenAI `parallel_tool_calls`. */
     parallelToolCalls?: boolean;
+    /** OpenAI Responses fields requested in the response payload. */
+    include?: OpenAIResponseInclude[];
     /** Effort-level reasoning request (OpenAI Responses / Chat `reasoning_effort`). */
     reasoning?: Effort;
     /** Force-disable reasoning (Anthropic `thinking: { type: "disabled" }`). */

package/dist/types/auth-storage.d.ts

@@ -11,7 +11,7 @@ import { Database } from "bun:sqlite";
 import type { ApiKeyResolver } from "./auth-retry.js";
 import type { OAuthAuthInfo, OAuthController, OAuthCredentials, OAuthProviderId } from "./registry/oauth/types.js";
 import type { Provider } from "./types.js";
-import type { CredentialRankingStrategy, UsageCostHistoryEntry, UsageCostHistoryQuery, UsageHistoryEntry, UsageHistoryQuery, UsageLogger, UsageProvider, UsageReport } from "./usage.js";
+import type { ClientUsageReport, ClientUsageSummary, CredentialRankingStrategy, ObservedUsageEntry, UsageCostHistoryEntry, UsageCostHistoryQuery, UsageHistoryEntry, UsageHistoryQuery, UsageLogger, UsageProvider, UsageReport } from "./usage.js";
 import { type CodexResetConsumeCode, type CodexResetCredit } from "./usage/openai-codex-reset.js";
 export type ApiKeyCredential = {
     type: "api_key";
@@ -281,6 +281,16 @@ export interface AuthCredentialStore {
     listUsageCosts?(query?: UsageCostHistoryQuery): UsageCostHistoryEntry[];
     /** Read recorded usage-limit snapshots, oldest first. */
     listUsageHistory?(query?: UsageHistoryQuery): UsageHistoryEntry[];
+    /**
+     * Client hook: forward locally observed request usage. Remote broker stores
+     * batch these to the broker so it can attribute token burn per install;
+     * local stores omit it and observation is skipped.
+     */
+    recordObservedUsage?(entries: ObservedUsageEntry[]): void;
+    /** Broker host: persist one client's observed-usage report. */
+    recordClientUsage?(report: ClientUsageReport): void;
+    /** Broker host: aggregate recorded per-client usage since a timestamp. */
+    getClientUsageSummary?(sinceMs: number): ClientUsageSummary;
     /**
      * Optional store-supplied OAuth refresh. When present, `AuthStorage` uses
      * it before the per-provider local refresh path. `RemoteAuthCredentialStore`
@@ -573,6 +583,8 @@ export interface OAuthAccountSummary {
     /** Organization/workspace the credential is scoped to (Anthropic/ChatGPT multi-subscription). */
     orgId?: string;
     orgName?: string;
+    /** True when this account is the session-sticky OAuth credential requested by `listOAuthAccounts`. */
+    active: boolean;
 }
 export interface InvalidateCredentialMatchingOptions {
     signal?: AbortSignal;
@@ -834,6 +846,28 @@ export declare class AuthStorage {
         recordedAt?: number;
         baseUrl?: string;
     }): boolean;
+    /**
+     * Forward one completed request's usage to the store's observer hook.
+     * Broker-backed stores batch these into per-install reports so the broker
+     * can track actual token burn per client; local stores have no hook and
+     * the call is a no-op.
+     */
+    recordObservedUsage(entry: {
+        provider: Provider;
+        model: string;
+        usage: {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+        };
+        costUsd?: number;
+        at?: number;
+    }): void;
+    /** Broker host: persist one client's observed-usage report (per-install token burn). */
+    recordClientUsage(report: ClientUsageReport): boolean;
+    /** Broker host: aggregate recorded per-client usage since `sinceMs`. */
+    getClientUsageSummary(sinceMs: number): ClientUsageSummary;
     ingestUsageHeaders(provider: Provider, headers: Record<string, string>, options?: {
         sessionId?: string;
         baseUrl?: string;
@@ -957,8 +991,20 @@ export declare class AuthStorage {
      * order, WITHOUT refreshing any token. The array position (0-based) is the
      * selector accepted by {@link AuthStorage.getOAuthAccessAt}; a "pick the Nth
      * account" UI should render `position + 1`.
+     *
+     * When `sessionId` is supplied, the session-sticky OAuth credential is marked
+     * `active`. No account is active before that session has resolved or pinned a
+     * credential.
+     */
+    listOAuthAccounts(provider: string, sessionId?: string): OAuthAccountSummary[];
+    /**
+     * Pin one stored OAuth account as this session's preferred credential.
+     *
+     * The durable credential id keeps the pin stable across credential refreshes,
+     * storage reordering, and process restarts. Normal auth retry and usage-limit
+     * handling may still route around an unavailable account.
      */
-    listOAuthAccounts(provider: string): OAuthAccountSummary[];
+    pinSessionOAuthAccount(provider: string, sessionId: string, credentialId: number): boolean;
     /**
      * Resolve every stored OAuth credential for `provider` independently.
      *
@@ -1186,6 +1232,8 @@ export declare class SqliteAuthCredentialStore implements AuthCredentialStore {
     listUsageHistory(query?: UsageHistoryQuery): UsageHistoryEntry[];
     recordUsageCosts(entries: UsageCostHistoryEntry[]): void;
     listUsageCosts(query?: UsageCostHistoryQuery): UsageCostHistoryEntry[];
+    recordClientUsage(report: ClientUsageReport): void;
+    getClientUsageSummary(sinceMs: number): ClientUsageSummary;
     /**
      * Save OAuth credentials for a provider.
      * Preserves unrelated identities and replaces only the matching credential.

package/dist/types/providers/anthropic-wire.d.ts

@@ -57,6 +57,33 @@ export type ToolResultBlockParam = {
     is_error?: boolean;
     cache_control?: CacheControlEphemeral | null;
 };
+/** Anthropic-executed server tool call replayed inside an assistant turn. */
+export type ServerToolUseBlockParam = {
+    type: "server_tool_use";
+    id: string;
+    name: string;
+    input?: Record<string, unknown> | null;
+    [key: string]: unknown;
+};
+/** Web-search server-tool call whose matching result is replayable by omp. */
+export type WebSearchServerToolUseBlockParam = ServerToolUseBlockParam & {
+    name: "web_search";
+};
+/** Native web-search result replayed inside an assistant turn. */
+export type WebSearchToolResultBlockParam = {
+    type: "web_search_tool_result";
+    tool_use_id: string;
+    content: unknown;
+    [key: string]: unknown;
+};
+/** True for the complete native web-search history variants omp can replay. */
+export declare function isAnthropicWebSearchHistoryBlock(block: {
+    type: string;
+    name?: unknown;
+    id?: unknown;
+    tool_use_id?: unknown;
+    content?: unknown;
+}): block is WebSearchServerToolUseBlockParam | WebSearchToolResultBlockParam;
 export type ThinkingBlockParam = {
     type: "thinking";
     thinking: string;
@@ -81,7 +108,7 @@ export type FallbackBlockParam = {
         model: string;
     };
 };
-export type ContentBlockParam = TextBlockParam | ImageBlockParam | ToolUseBlockParam | ToolResultBlockParam | ThinkingBlockParam | RedactedThinkingBlockParam | FallbackBlockParam;
+export type ContentBlockParam = TextBlockParam | ImageBlockParam | ToolUseBlockParam | ToolResultBlockParam | ServerToolUseBlockParam | WebSearchToolResultBlockParam | ThinkingBlockParam | RedactedThinkingBlockParam | FallbackBlockParam;
 /**
  * A single conversation turn.
  *
@@ -257,7 +284,7 @@ export type ResponseContentBlock = {
     id: string;
     name: string;
     input?: Record<string, unknown> | null;
-} | {
+} | ServerToolUseBlockParam | WebSearchToolResultBlockParam | {
     type: "fallback";
     from: {
         model: string;

package/dist/types/providers/anthropic.d.ts

@@ -1,6 +1,6 @@
 import type { FetchImpl, Message, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, StreamFunction, StreamOptions, Usage } from "../types.js";
 import { type AnthropicFetchOptions, type AnthropicMessagesClientLike } from "./anthropic-client.js";
-import type { FallbackParam, MessageParam, TextBlockParam } from "./anthropic-wire.js";
+import { type FallbackParam, type MessageParam, type TextBlockParam } from "./anthropic-wire.js";
 export type AnthropicHeaderOptions = {
     apiKey: string;
     baseUrl?: string;

package/dist/types/providers/openai-codex/request-transformer.d.ts

@@ -35,6 +35,10 @@ export interface InputItem {
     name?: string;
     output?: unknown;
     arguments?: unknown;
+    action?: unknown;
+    actions?: unknown;
+    pending_safety_checks?: unknown;
+    acknowledged_safety_checks?: unknown;
     /** `additional_tools` developer item payload (Responses Lite). */
     tools?: unknown;
 }
@@ -65,8 +69,10 @@ export interface RequestBody {
 }
 /**
  * Resolve whether a Codex request uses the Responses Lite transport: an
- * explicit option wins, otherwise the model's catalog flag (codex-rs
- * `model_info.use_responses_lite`) decides.
+ * explicit option wins, then the `PI_CODEX_RESPONSES_LITE` env override
+ * (`1`/`true` forces Lite, `0`/`false` forces the full Responses body),
+ * otherwise the model's catalog flag (codex-rs `model_info.use_responses_lite`)
+ * decides.
  */
 export declare function resolveCodexResponsesLite(model: Model<"openai-codex-responses">, requested: boolean | undefined): boolean;
 /**

package/dist/types/providers/openai-codex-responses.d.ts

@@ -7,7 +7,6 @@ export interface OpenAICodexResponsesOptions extends StreamOptions {
     /** `reasoning.context` replay scope; defaults to `all_turns` when unset. The `all_turns` value is gated to gpt-5.4+ Codex models — older ids reject it, so it is suppressed and `context` omitted. */
     reasoningContext?: CodexReasoningContext;
     textVerbosity?: "low" | "medium" | "high";
-    include?: string[];
     codexMode?: boolean;
     toolChoice?: ToolChoice;
     preferWebsockets?: boolean;
@@ -64,6 +63,28 @@ export declare function createOpenAICodexCompactionRequestContext(options: {
     context: CodexCompactionContext | undefined;
     implementation: "responses" | "responses_compaction_v2" | "responses_compact";
 }): CodexCompactionRequestContext | undefined;
+/**
+ * Host integration boundary for just-in-time `x-oai-attestation` header
+ * values (codex-rs `AttestationProvider`). Resolves to the full header value
+ * — an `{"v":1,"s":0,"t":"v1.…"}` envelope — or `undefined` when no
+ * attestation should be sent.
+ */
+export type CodexAttestationProvider = () => Promise<string | undefined>;
+/**
+ * Install the process-wide attestation hook consulted for upstream Codex
+ * requests (codex-rs stores its provider on `ModelClient` construction). The
+ * hook is only consulted for ChatGPT-OAuth credentials and runs just-in-time
+ * per request; WebSocket handshakes resolve once per connection because the
+ * header is connection-scoped there.
+ */
+export declare function setCodexAttestationProvider(provider: CodexAttestationProvider | undefined): void;
+/**
+ * Resolve the `x-oai-attestation` header value for one upstream request.
+ * Gated on ChatGPT-OAuth credentials (a Codex JWT carries `chatgpt_account_id`;
+ * codex-rs gates on `auth.is_chatgpt_auth()`). A throwing hook degrades to no
+ * header rather than failing the request.
+ */
+export declare function getCodexAttestationHeader(accountId: string | undefined): Promise<string | undefined>;
 type CodexTransport = "sse" | "websocket";
 /** Shape of the Codex request sent on the latest provider turn. */
 export interface OpenAICodexTurnRequestDiagnostics {