@linxiraos/pi-ai 1.1.26 → 1.2.0

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

@@ -906,60 +906,6 @@ export declare namespace Response {
              */
             type: "error";
         }
-        /**
-         * A moderation result produced for the response input or output.
-         */
-        interface ModerationResult {
-            /**
-             * A dictionary of moderation categories to booleans, True if the input is flagged
-             * under this category.
-             */
-            categories: {
-                [key: string]: boolean;
-            };
-            /**
-             * Which modalities of input are reflected by the score for each category.
-             */
-            category_applied_input_types: {
-                [key: string]: Array<"text" | "image">;
-            };
-            /**
-             * A dictionary of moderation categories to scores.
-             */
-            category_scores: {
-                [key: string]: number;
-            };
-            /**
-             * A boolean indicating whether the content was flagged by any category.
-             */
-            flagged: boolean;
-            /**
-             * The moderation model that produced this result.
-             */
-            model: string;
-            /**
-             * The object type, which was always `moderation_result` for successful moderation
-             * results.
-             */
-            type: "moderation_result";
-        }
-        /**
-         * An error produced while attempting moderation for the response input or output.
-         */
-        interface Error {
-            /**
-             * The error code.
-             */
-            code: string;
-            /**
-             * The error message.
-             */
-            message: string;
-            /**
-             * The object type, which was always `error` for moderation failures.
-             */
-            type: "error";
-        }
     }
 }
 /**
@@ -3506,7 +3452,7 @@ export declare namespace ResponseInputItem {
     }
     /**
      * Changes reasoning effort for subsequent responses without touching the
-     * request-level `reasoning.effort` (GPT-6 Astra). Must not be adjacent to
+     * request-level `reasoning.effort` (GPT-6 family). Must not be adjacent to
      * another `configuration_update`.
      */
     interface ConfigurationUpdate {

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

@@ -16,9 +16,9 @@ export interface OpenAIResponsesOptions extends StreamOptions {
     /**
      * Stateful turns: chain via `previous_response_id` + delta input instead of
      * replaying the full transcript. Forces `store: true` (the platform only
-     * resolves stored responses). Defaults ON against the official OpenAI API
-     * and OFF for other Responses endpoints; `PI_OPENAI_STATEFUL` overrides the
-     * default, and `false` here vetoes everything. Requires `sessionId` +
+     * resolves stored responses). Precedence: this option, then
+     * `PI_OPENAI_STATEFUL`, then `compat.statefulResponses`, then ON against the
+     * official OpenAI API and OFF elsewhere. Requires `sessionId` +
      * `providerSessionState`. Falls back to a full replay whenever history
      * mutates or the server reports a stale id.
      */
@@ -60,8 +60,36 @@ export interface OpenAIResponsesOptions extends StreamOptions {
     /** Opt-in GPT-5.6+ prompt-cache policy. Unsupported explicit mode fails locally. */
     promptCache?: OpenAIPromptCacheOptions;
 }
+/**
+ * Poll a stored Responses result until it reaches an adoptable terminal state.
+ * 404s, 5xx, and transport failures mean "not yet" (an in-flight run only
+ * becomes retrievable once the server finishes it); any other status, a
+ * mismatched id, or a failed/cancelled run ends the poll immediately. The
+ * whole recovery is bounded by one wall-clock deadline: each request's timeout
+ * is clamped to the time left, and no sleep may cross the deadline, so a
+ * stalled host cannot hold an already-failed turn past it. Returns the
+ * terminal object, or undefined on give-up/abort.
+ *
+ * @internal Exported for tests.
+ */
+export declare function pollOpenAIResponsesResultForCompletion(args: {
+    fetchImpl: NonNullable<StreamOptions["fetch"]>;
+    url: string;
+    headers: Record<string, string>;
+    responseId: string;
+    signal?: AbortSignal;
+    /** Sleep between polls; defaults to a real wait honoring `signal`. */
+    wait?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}): Promise<Record<string, unknown> | undefined>;
 interface OpenAIResponsesProviderSessionState extends ProviderSessionState, OpenAIStrictToolsState, OpenAIReasoningEffortFallbackState {
+    /**
+     * Replay native history items. Starts false only on connection-bound hosts;
+     * `close()` clears it so the next request rebuilds history from message
+     * content; the first successful response sets it.
+     */
     nativeHistoryReplayWarmed: boolean;
+    /** Bumped by `close()`; a response warms the state only if no close happened since its request started. */
+    closeCount: number;
     /** Stateful `previous_response_id` chain baselines, keyed by baseUrl/model/session. */
     chains: Map<string, OpenAIResponsesChainState>;
     /** `configuration_update` effort baselines, keyed by baseUrl/model/session. */
@@ -70,6 +98,7 @@ interface OpenAIResponsesProviderSessionState extends ProviderSessionState, Open
 /** Wire efforts a `configuration_update` can carry: every real tier, never `none`/null. */
 type ResponsesStableEffort = Exclude<ReasoningEffort, "none" | null>;
 interface OpenAIResponsesChainState {
+    sessionId: string;
     /**
      * Wire params of the last successful turn; never carries
      * `previous_response_id`.
@@ -85,6 +114,14 @@ interface OpenAIResponsesChainState {
     /** Set once chaining is judged unsupported for this session (circuit breaker). */
     disabled: boolean;
 }
+/**
+ * Set the process-wide storage default per provider id, used when a request
+ * leaves `storeResponses` unset. Hosts call this from their settings so every
+ * request follows the setting, including direct `streamSimple`/`completeSimple`
+ * side calls that do not pass per-request options. `PI_MUSE_STORE_RESPONSES`
+ * still overrides it.
+ */
+export declare function configureProviderStoreResponses(byProvider: Readonly<Record<string, boolean>> | undefined): void;
 /**
  * Drop the account-bound half of every retained `openai-responses` record in
  * `states`: the stateful `previous_response_id` chain baselines.

package/dist/types/providers/openai-shared.d.ts

@@ -27,7 +27,7 @@ export interface OpenAIStrictToolsState {
 export interface OpenAIRequestSetupModel extends OpenAIModelIdentity {
     headers?: Record<string, string>;
     premiumMultiplier?: number;
-    compat?: Pick<ResolvedOpenAISharedCompat, "promptCacheSessionHeader">;
+    compat?: Pick<ResolvedOpenAISharedCompat, "promptCacheSessionHeader" | "sessionHeader">;
 }
 /** Cache identity controls shared by OpenAI-family transports. */
 export interface OpenAICacheOptions {
@@ -76,9 +76,18 @@ export declare function applyOpenAIServiceTier(params: {
  * resolved request tier. Scoped to `provider: "openai"` (the only standard
  * Responses biller) so an echoed `service_tier` from an Azure/OpenRouter/Copilot
  * proxy can never skew those costs.
+ *
+ * Returns the tier the turn ran on for the caller to record on the message, and
+ * counts the premium request the tier bills.
+ */
+export declare function applyOpenAIResponsesServiceTierCost(model: Pick<Model, "provider" | "serviceTierCost" | "api" | "identity">, usage: AssistantMessage["usage"], responseServiceTier: unknown, requestServiceTier: ServiceTier | null | undefined): ServiceTier | undefined;
+/**
+ * Reconcile token-price estimates with a gateway's authoritative account charge.
+ * BYOK turns (`is_byok: true`) price from the provider spend in
+ * `cost_details.upstream_inference_cost` plus whatever credits charge
+ * OpenRouter reports in `cost` (its BYOK fee is plan-dependent and can be $0),
+ * so both are covered.
  */
-export declare function applyOpenAIResponsesServiceTierCost(model: Pick<Model, "provider" | "serviceTierCost">, usage: AssistantMessage["usage"], responseServiceTier: unknown, requestServiceTier: ServiceTier | null | undefined): void;
-/** Reconcile token-price estimates with a gateway's authoritative account charge. */
 export declare function applyProviderReportedCost(model: Pick<Model, "provider">, usage: Usage, rawUsage: unknown): void;
 export interface OpenAIUsageAccountingInput {
     promptTokens: number;
@@ -470,6 +479,13 @@ export interface BuildResponsesInputOptions<TApi extends Api> {
     supportsImageDetailOriginal: boolean;
     systemRole?: "system" | "developer";
     nativeHistory?: {
+        /**
+         * Replay same-provider native history. `false` marks a cold provider
+         * session (#489): native items are withheld except remote-compaction
+         * history and assistant turns that carry no server-issued state
+         * ({@link isColdReplayableResponsesTurn}); other turns are rebuilt from
+         * message content.
+         */
         replay: boolean;
         filterReasoning: boolean;
     };
@@ -577,12 +593,20 @@ export interface SequentialCutoffSummaryState {
 export declare function createSequentialCutoffSummaryState(): SequentialCutoffSummaryState;
 /** Chooses final reasoning text without making sequential-cutoff results disagree with emitted deltas. */
 export declare function finalizeReasoningThinking(item: ResponseReasoningItem, streamedThinking: string, cutoff?: SequentialCutoffSummaryState): string;
+/**
+ * Records whether a finalized reasoning block holds a provider-written summary
+ * or the model's own trace, following `finalizeReasoningThinking`'s choice of
+ * text: the done item's summary wins, then its `reasoning_text` content, then
+ * the streamed deltas, which the summary handlers mark on the block as they
+ * append.
+ */
+export declare function settleReasoningSummary(item: ResponseReasoningItem, block: ThinkingContent): void;
 export declare function appendReasoningSummaryTextDelta(item: ResponseReasoningItem, block: ThinkingContent, delta: string, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number, summaryIndex?: number): void;
 /**
  * Applies a completed reasoning-summary snapshot, including providers that omit
  * the preceding summary-part event.
  */
-export declare function applyReasoningSummaryTextDone(item: ResponseReasoningItem, block: ThinkingContent, text: string, summaryIndex: number, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number): void;
+export declare function applyReasoningSummaryTextDone(item: ResponseReasoningItem, block: ThinkingContent, text: string, summaryIndex: number | undefined, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number): void;
 export declare function appendReasoningSummaryPartDone(item: ResponseReasoningItem, block: ThinkingContent, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number): void;
 /**
  * Applies an atomic `response.reasoning_summary_text.done` snapshot.
@@ -606,7 +630,8 @@ export declare function accumulateToolCallArgumentsDelta(block: ResponsesToolCal
  * Finalize streamed function-call arguments from the authoritative `.done`
  * payload. The caller owns the `argumentsDone` flag (generic Responses sets it;
  * Codex's block shape has no such field), so this only rewrites `arguments` and
- * drops the transient accumulation fields.
+ * drops the transient accumulation fields. A blank payload is not authoritative:
+ * it parses the buffered deltas and keeps them so the final item can still win.
  */
 export declare function finalizeToolCallArgumentsDone(block: ResponsesToolCallBlock, args: string): void;
 export declare function accumulateCustomToolCallInputDelta(block: ResponsesToolCallBlock, delta: string, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number): void;

package/dist/types/providers/pi-native-client.d.ts

@@ -1,6 +1,6 @@
 import type { Api, AssistantMessageEventStream as AssistantMessageEventStreamType, Context, Model, SimpleStreamOptions } from "../types.js";
 /**
- * Stream a turn through an `omp auth-gateway` over the pi-native protocol.
+ * Stream a turn through an `zetacode auth-gateway` over the pi-native protocol.
  *
  * The returned {@link AssistantMessageEventStream} receives each parsed
  * `AssistantMessageEvent` verbatim from the gateway; the terminal `done` /

package/dist/types/providers/transform-messages.d.ts

@@ -1,4 +1,29 @@
 import type { Api, AssistantMessage, Message, Model } from "../types.js";
+/**
+ * Maximum tool-call id length the strictest replay provider accepts.
+ *
+ * Anthropic requires `^[a-zA-Z0-9_-]+$` with a 64-char cap; Google and Codex
+ * `normalizeToolCallId` implementations cap individual id segments to the same
+ * 64-char ceiling. Replacement ids minted here flow back through
+ * `convertAnthropicMessages` (and friends) unchanged, so the `_dupN` suffix
+ * MUST not push a normalized id past this bound.
+ */
+export declare const MAX_TOOL_CALL_ID_LENGTH = 64;
+/**
+ * OpenAI Responses-family APIs mint composite tool ids (`call_id|item_id`);
+ * opaque Chat Completions ids do not (openai-completions preserves same-model
+ * ids verbatim as provider correlation tokens), so ONLY these origins may be
+ * canonicalized to their `call_` component for pairing.
+ */
+export declare function isResponsesFamilyApi(api: Api | undefined): boolean;
+/**
+ * The wire `call_id` component of a (possibly composite) Responses id: the
+ * FIRST segment before `|`. A degenerate `|itemId` (empty call half, pipe at
+ * index 0) keeps its full id so unrelated empty-half ids never collapse onto
+ * one empty-string bucket.
+ */
+export declare function responsesCallComponent(id: string): string;
+export declare function appendDuplicateSuffix(originalId: string, suffix: string, maxLength: number): string;
 /**
  * Whether a tool-call name cannot belong to any declared tool: missing, empty,
  * longer than OpenAI's 128-character replay limit, or containing whitespace or

package/dist/types/providers/vision-guard.d.ts

@@ -23,7 +23,7 @@ export declare function isOpenAICompletionsVisionSupported(model: Model<"openai-
  * guard, as does the OpenRouter chat fallback (`PI_OPENROUTER_RESPONSES=0`,
  * which dispatches `openrouter` models through `streamOpenAICompletions`);
  * every other API ships the modalities the model declares. Callers that report
- * or gate on the wire (for example the `omp models` table) read this
+ * or gate on the wire (for example the `zetacode models` table) read this
  * predicate; declared capability reads `model.input`.
  */
 export declare function sendsImageInputOnWire(model: Model<Api>): boolean;

package/dist/types/registry/oauth/cloudflare-workers-ai.d.ts

@@ -0,0 +1,3 @@
+import type { OAuthController } from "./types.js";
+/** Collect the Workers AI API token and account id used by CLI, setup-wizard, and TUI login callers. */
+export declare function loginCloudflareWorkersAi(options: OAuthController): Promise<string>;

package/dist/types/registry/oauth/cursor.d.ts

@@ -1,3 +1,4 @@
+import type { FetchImpl } from "../../types.js";
 import type { OAuthController, OAuthCredentials } from "./types.js";
 export interface CursorAuthParams {
     verifier: string;
@@ -12,7 +13,14 @@ export declare function pollCursorAuth(uuid: string, verifier: string): Promise<
 }>;
 export declare function loginCursor(onAuthUrl: (url: string) => void, onPollStart?: () => void): Promise<OAuthCredentials>;
 export declare function loginCursorHook(callbacks: OAuthController): Promise<OAuthCredentials>;
-export declare function refreshCursorToken(apiKeyOrRefreshToken: string): Promise<OAuthCredentials>;
-export declare function refreshCursorHook(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+export declare function refreshCursorToken(refreshToken: string): Promise<OAuthCredentials>;
+export declare function refreshCursorHook(credentials: OAuthCredentials, signal?: AbortSignal): Promise<OAuthCredentials>;
+/** Request headers that present `accessToken` to cursor.com as its user's web session. */
+export declare function cursorSessionHeaders(userId: string, accessToken: string): Record<string, string>;
+/**
+ * Email of the Cursor account that owns `accessToken`, read from its cursor.com
+ * profile. Undefined when the token names no user or the profile names another.
+ */
+export declare function fetchCursorAccountEmail(accessToken: string, fetchImpl?: FetchImpl, signal?: AbortSignal): Promise<string | undefined>;
 export declare function extractCursorAccessTokenUserId(accessToken: string): string | undefined;
 export declare function isCursorTokenExpiringSoon(token: string, thresholdSeconds?: number): boolean;

package/dist/types/registry/oauth/index.d.ts

@@ -43,3 +43,5 @@ export declare function getOAuthApiKey(provider: OAuthProvider, credentials: Rec
  * Get list of OAuth providers.
  */
 export declare function getOAuthProviders(): OAuthProviderInfo[];
+/** Provider id that stores `providerId`'s credentials: login aliases (`openai-codex-device`) map to their target (`openai-codex`). */
+export declare function getOAuthCredentialProvider(providerId: string): string;

package/dist/types/registry/oauth/snowflake.d.ts

@@ -0,0 +1,3 @@
+import type { OAuthController, OAuthCredentials } from "./types.js";
+export declare function loginSnowflake(ctrl: OAuthController): Promise<OAuthCredentials>;
+export declare function refreshSnowflakeToken(credentials: OAuthCredentials, signal?: AbortSignal): Promise<OAuthCredentials>;

package/dist/types/registry/snowflake.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderTransport } from "./build.js";
+/** Normalize account identifiers and Snowsight links without accepting arbitrary credential-receiving hosts. */
+export declare function normalizeSnowflakeAccountUrl(input: string): string;
+export declare const snowflakeTransport: ProviderTransport;

package/dist/types/stream.d.ts

@@ -31,27 +31,6 @@ export declare const __providerInFlightForTesting: {
     captureStaleLockRelease(provider: string): Promise<(() => Promise<void>) | null>;
     captureLockDirRelease(provider: string): Promise<(() => Promise<void>) | null>;
 };
-/**
- * Get API key for provider from known environment variables, e.g. OPENAI_API_KEY.
- *
- * Will not return API keys for providers that require OAuth tokens.
- * Checks Bun.env, then cwd/.env, then ~/.env.
- */
-export declare function getEnvApiKey(provider: string): string | undefined;
-/**
- * Name of the environment variable that backs `getEnvApiKey` for a provider,
- * when that provider maps to a single named variable (e.g. `github-copilot` →
- * `COPILOT_GITHUB_TOKEN`). Returns undefined for providers whose env fallback
- * is computed (multi-var pickers, Vertex ADC / Bedrock probes, …) since no
- * single variable name describes the source.
- */
-export declare function getEnvApiKeyName(provider: string): string | undefined;
-/**
- * Enumerate every provider that has an env-var fallback for `getEnvApiKey`.
- * Used by `zeta-c auth-broker migrate --include-env` to discover env-sourced keys
- * that should be uploaded to the broker.
- */
-export declare function listProvidersWithEnvKey(): string[];
 export declare function stream<TApi extends Api>(model: Model<TApi>, context: Context, options?: OptionsForApi<TApi>): AssistantMessageEventStream;
 export declare function complete<TApi extends Api>(model: Model<TApi>, context: Context, options?: OptionsForApi<TApi>): Promise<AssistantMessage>;
 export declare function streamSimple<TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;

package/dist/types/transcription/types.d.ts

@@ -2,7 +2,8 @@ import type { Usage } from "@linxiraos/pi-catalog/types";
 export type TranscriptionResponseFormat = "json" | "verbose_json";
 export type TranscriptionTimestampGranularity = "word" | "segment";
 export interface TranscriptionRequest {
-    audio: Uint8Array;
+    /** Audio bytes. A `Blob`/`File` (e.g. a parsed multipart upload) is sent without copying. */
+    audio: Uint8Array | Blob;
     mimeType: string;
     fileName?: string;
     language?: string;

package/dist/types/types.d.ts

@@ -157,18 +157,31 @@ export declare function shouldSendServiceTier(serviceTier: ServiceTier | null |
  */
 export declare function realizesPriorityServiceTier(serviceTier: ServiceTier | null | undefined, model: ServiceTierModel): boolean;
 /**
- * Premium-request weight contributed by a priority request to a provider that
- * realizes it and bills extra. Mirrors GitHub Copilot's `premiumRequests`
- * accounting so the "premium requests" stat aggregates priority traffic across
- * the OpenAI family, direct Anthropic fast mode, and Google priority.
+ * Premium-request weight contributed by a request a provider bills above
+ * standard. Priority (Fast mode) counts 1 on every provider that realizes it;
+ * `ultrafast` counts 1 on the OpenAI family, where it is a premium serving tier
+ * (its cost premium is recorded separately in `usage.cost`). Mirrors GitHub
+ * Copilot's `premiumRequests` accounting so the "premium requests" stat
+ * aggregates premium traffic across the OpenAI family, direct Anthropic fast
+ * mode, and Google priority.
  *
- * Returns 1 only when priority is actually realized on the wire for `model`
- * (see {@link realizesPriorityServiceTier}) and the provider bills it as a
- * premium request. OpenRouter is excluded — it bills per its own pricing, not
- * Copilot-premium semantics — as are Bedrock/Vertex Claude, where priority is
- * silently dropped.
+ * Returns 1 only when the tier is actually realized on the wire for `model`
+ * (see {@link realizesPriorityServiceTier} and {@link shouldSendServiceTier})
+ * and the provider bills it as a premium request. OpenRouter is excluded — it
+ * bills per its own pricing, not Copilot-premium semantics — as are
+ * Bedrock/Vertex Claude, where priority is silently dropped.
+ *
+ * Pass `served: true` when the tier is the one the provider reported serving
+ * (an assistant message's {@link AssistantMessage.serviceTier}) rather than a
+ * requested setting: realization is then already proven, so the wire gate is
+ * skipped and a model without discovery metadata (a stats-backfill row) still
+ * counts.
  */
-export declare function getPriorityPremiumRequests(serviceTier: ServiceTier | null | undefined, model: ServiceTierModel): number;
+export declare function getPremiumServiceTierRequests(serviceTier: ServiceTier | null | undefined, model: ServiceTierModel, options?: {
+    served?: boolean;
+}): number;
+/** Parse a provider-reported `service_tier` echo into a known tier, or `undefined` for anything else. */
+export declare function parseServiceTier(value: unknown): ServiceTier | undefined;
 /**
  * Coerce a persisted service-tier value to a {@link ServiceTierByFamily}. Newer
  * sessions store the family map directly; legacy sessions stored a single
@@ -178,6 +191,8 @@ export declare function getPriorityPremiumRequests(serviceTier: ServiceTier | nu
 export declare function coerceServiceTierByFamily(value: unknown): ServiceTierByFamily | undefined;
 export interface ProviderSessionState {
     close(): void;
+    /** Release one routing session after its final request, preserving shared provider fallbacks. */
+    releaseSession?(sessionId: string): void;
 }
 export interface ProviderResponseMetadata {
     status: number;
@@ -215,6 +230,11 @@ export interface CodexCompactionRequestContext extends CodexCompactionMetadata {
 export interface AnthropicCompactionRequest {
     /** Custom summarization prompt; replaces the API default entirely when set. */
     instructions?: string;
+    /**
+     * Replayed summaries' file metadata due before this time (ms) ends the request;
+     * later metadata replays with the retained tail, which the new summary carries.
+     */
+    filesDueBefore?: number;
 }
 /** OpenAI's GPT-5.6+ explicit prompt-cache controls. */
 export interface OpenAIPromptCacheOptions {
@@ -333,6 +353,16 @@ export interface StreamOptions {
      * `false` so `previous_response_id` cannot explain a result.
      */
     statefulResponses?: boolean;
+    /**
+     * Store this request's result server-side on hosts that support it
+     * (`compat.storeResponses`, e.g. Muse Code), so a stream that drops
+     * mid-turn resumes from `GET /responses/{id}` instead of re-running the
+     * turn. Privacy: stored runs retain prompts and outputs on the provider.
+     * Unset falls back to `PI_MUSE_STORE_RESPONSES`, then the host's
+     * `configureProviderStoreResponses` default, else off. Ignored on hosts
+     * without the capability.
+     */
+    storeResponses?: boolean;
     /**
      * Disable native reasoning when the caller supplies an external scratchpad.
      * OpenAI Responses emits `reasoning: { effort: "none" }`; Anthropic and
@@ -344,6 +374,21 @@ export interface StreamOptions {
      * Providers can use this to persist transport/session state between turns.
      */
     providerSessionState?: Map<string, ProviderSessionState>;
+    /**
+     * Session a side request branches from, so it can read the parent's cached
+     * prefix. Providers that keep per-conversation request controls (OpenAI
+     * `configuration_update` effort baselines) plan the request against a copy
+     * of that session's controls, never changing the parent's state; the Codex
+     * backend also routes it with the parent's cache affinity (session headers).
+     */
+    parentSessionId?: string;
+    /**
+     * Run at the model's lowest effort where the transport carries the change as
+     * a per-message control that keeps the cached prefix (Anthropic per-message
+     * effort, OpenAI `configuration_update`). Elsewhere the requested effort
+     * applies unchanged: changing request-level reasoning forfeits the cache.
+     */
+    minimizeEffort?: boolean;
     /**
      * Source of user steering a provider may deliver into the response it is
      * streaming (OpenAI Responses `response.steer` over the Codex WebSocket).
@@ -363,6 +408,8 @@ export interface StreamOptions {
      * are not covered.
      */
     maxInFlightRequests?: Record<string, number>;
+    /** @internal Keep the in-flight permit until a provider's bounded terminal drain finishes. */
+    waitForTerminalDrain?: boolean;
     /**
      * Optional callback for inspecting or replacing provider payloads before sending.
      * Return undefined to keep the payload unchanged.
@@ -587,6 +634,17 @@ export interface ThinkingContent {
     thinking: string;
     thinkingSignature?: string;
     itemId?: string;
+    /**
+     * `true`: `thinking` is a provider-written summary of the model's reasoning
+     * (OpenAI Responses `summary_text`, Gemini thought summaries). `false`: the
+     * wire delivered it as the reasoning itself, not marked as a summary
+     * (chat-completions reasoning fields, Responses `reasoning_text`, Devin
+     * `thinking`); whether that is the full trace is vouched for per family by
+     * the catalog's `portable-reasoning`. Unset when provenance is unknown,
+     * including turns recorded before parsers set it. Only `false` blocks
+     * replay natively on another host.
+     */
+    summary?: boolean;
 }
 export interface RedactedThinkingContent {
     type: "redactedThinking";
@@ -820,13 +878,48 @@ export interface AnthropicCompactionPayload {
     encryptedContent?: string;
     /**
      * Harness-appended file metadata (`<files>` section) kept out of the
-     * byte-identical block. Replayed as a user message after the native block:
-     * the converter replaces the summary message with the block and skips its
-     * text, so without this the metadata would be invisible to this provider.
+     * byte-identical block. The converter replaces the summary message with the
+     * block and skips its text, so it replays this as a user message after the
+     * block's retained tail: before the first message created after the summary.
      */
     filesText?: string;
+    /**
+     * File metadata of earlier summaries whose replay position lies inside this
+     * summary's retained tail. Retained messages must reach the API unchanged,
+     * so each keeps replaying where it did: before the first message created
+     * after `after` (the earlier summary's commit time).
+     */
+    retainedFiles?: AnthropicCompactionFiles[];
+    /**
+     * Set on summaries whose retained tail replays unchanged: file metadata
+     * after the tail, earlier metadata at `retainedFiles`. Summaries persisted
+     * without it keep their original layout (metadata after the first retained
+     * turn), since later thinking was signed against those bytes.
+     */
+    exactTail?: true;
 }
-export type ProviderPayload = OpenAIResponsesHistoryPayload | AnthropicMessagePayload | AnthropicCompactionPayload;
+/** File metadata replayed at a fixed point of a natively compacted conversation. */
+export interface AnthropicCompactionFiles {
+    text: string;
+    /** Replays before the first message created after this time (ms). */
+    after: number;
+}
+/**
+ * Records Cursor's server wrote into the client's conversation store for one
+ * assistant turn: the `rootPromptMessagesJson` entries after the user's message,
+ * reasoning signatures and redacted reasoning included. Written and read by the
+ * Cursor provider, which sends them back unchanged to the wire model that produced them.
+ */
+export interface CursorHistoryPayload {
+    type: "cursorHistory";
+    /** Wire route the records were written under, as sent (requested model, details id, max mode, parameters). */
+    wireRoute: string;
+    /** Digest of the turn's opening user message, content and paired tool results when recorded; a rewritten turn rebuilds instead. */
+    digest: string;
+    /** Record bytes (UTF-8 JSON) in conversation order; each blob id is the SHA-256 of its bytes. */
+    records: string[];
+}
+export type ProviderPayload = OpenAIResponsesHistoryPayload | AnthropicMessagePayload | AnthropicCompactionPayload | CursorHistoryPayload;
 /** Provider-reported rewrite applied to request content before inference. */
 export interface ProviderInputTransformation {
     type: string;
@@ -928,6 +1021,15 @@ export interface AssistantMessage {
      * other than what was requested.
      */
     upstreamModel?: string;
+    /**
+     * Service tier the provider reported serving this turn, when the API echoes
+     * one (`response.service_tier`), falling back to the tier the request carried
+     * when the response omits the echo. Absent when the provider reports no tier
+     * or the echo cannot be trusted (proxies). This is the tier the turn actually
+     * ran on, which is what cost, premium-request, and speed accounting key on —
+     * the session's live setting may already have changed.
+     */
+    serviceTier?: ServiceTier;
     usage: Usage;
     stopReason: StopReason;
     stopDetails?: StopDetails | null;

package/dist/types/usage.d.ts

@@ -142,6 +142,8 @@ export interface UsageReport {
  * explicit fraction > used/limit > percent-unit used > inverted remaining.
  */
 export declare function resolveUsedFraction(limit: UsageLimit): number | undefined;
+/** Whether remaining quota is at or below the reserve (both 0..1 fractions). */
+export declare function isWithinUsageReserve(remainingFraction: number, reserveFraction: number): boolean;
 /**
  * One recorded usage-limit snapshot: a single limit window of one account at
  * a point in time. The usage cache itself is latest-snapshot-only; history

package/dist/types/utils/anthropic-auth.d.ts

@@ -9,6 +9,11 @@ export declare function resolveAnthropicBaseUrlFromEnv(): string | undefined;
  * Checks if a token is an OAuth token by looking for sk-ant-oat prefix.
  */
 export declare function isOAuthToken(apiKey: string): boolean;
+/** Optional request-shaping overrides for an already-resolved Anthropic credential. */
+export interface AnthropicAuthOptions {
+    /** Override token detection; false explicitly disables OAuth-style request shaping. */
+    isOAuth?: boolean;
+}
 /**
  * Build an {@link AnthropicAuthConfig} from an already-resolved API key.
  *
@@ -17,18 +22,27 @@ export declare function isOAuthToken(apiKey: string): boolean;
  * env-derived base; pass `undefined` to fall back to FOUNDRY/ANTHROPIC env
  * resolution and finally `DEFAULT_BASE_URL`.
  *
- * `isOAuth` is derived from the token prefix so the helper stays pure: callers
- * never have to thread the OAuth flag through their own resolution logic.
+ * `options.isOAuth` defaults to token detection. Pass the selected model's
+ * `isOAuth` to match the streaming path, which lets the model override the
+ * prefix (custom `anthropic-messages` providers default to OAuth shaping).
  */
-export declare function buildAnthropicAuthConfig(apiKey: string, baseUrl?: string): AnthropicAuthConfig;
+export declare function buildAnthropicAuthConfig(apiKey: string, baseUrl?: string, options?: AnthropicAuthOptions): AnthropicAuthConfig;
+/** Configured headers and fingerprint override policy for Anthropic hosted web search. */
+export interface AnthropicSearchHeaderOptions {
+    /** The selected model's configured headers (`ModelRegistry.resolveModelHeaders`). */
+    modelHeaders?: Record<string, string>;
+    /** The selected model's `compat.allowAnthropicHeaderOverrides`. */
+    allowAnthropicHeaderOverrides?: boolean;
+}
 /**
  * Builds HTTP headers for Anthropic API requests (search variant).
  *
- * Forwards `ANTHROPIC_CUSTOM_HEADERS` when the resolver deems them applicable
- * (Foundry mode, or a non-Anthropic base URL — typically an enterprise
- * gateway), matching the streaming path so web search behaves identically.
+ * Model headers and `ANTHROPIC_CUSTOM_HEADERS` (when the resolver deems them
+ * applicable: Foundry mode, or a non-Anthropic base URL such as an enterprise
+ * gateway) go through the same case-insensitive merge and enforced-header
+ * filtering as the streaming path, so web search behaves identically.
  */
-export declare function buildAnthropicSearchHeaders(auth: AnthropicAuthConfig): Record<string, string>;
+export declare function buildAnthropicSearchHeaders(auth: AnthropicAuthConfig, options?: AnthropicSearchHeaderOptions): Record<string, string>;
 /**
  * Builds the full API URL for Anthropic messages endpoint.
  */

package/dist/types/utils/aws-profile.d.ts

@@ -9,6 +9,11 @@ export declare function resolveAwsProfile(profile?: string): string;
  * the AWS SDK's `AWS_SDK_LOAD_CONFIG` opt-in.
  */
 export declare function shouldLoadAwsSharedConfig(profile?: string): boolean;
+/** Shared credentials and config file locations, honoring their env overrides. */
+export declare function awsSharedFilePaths(): {
+    credentialsPath: string;
+    configPath: string;
+};
 export declare function resolveAwsProfileRegion(profile?: string): string | undefined;
 /** Region selected by the environment or active shared-config profile. */
 export declare function resolveAwsAmbientRegion(profile?: string): string | undefined;

package/dist/types/utils/block-symbols.d.ts

@@ -72,6 +72,20 @@ export type DemotedThinkingCarrier = object & {
 };
 /** True for text blocks synthesized by cross-model thinking demotion. */
 export declare function isDemotedThinking(block: DemotedThinkingCarrier | null | undefined): boolean;
+/**
+ * Marks a thinking block that `transformMessages` carried natively from
+ * another host serving the same model (see `compat/reasoning-carry` in the
+ * catalog). Its host-bound signature and item id are gone, so encoders that
+ * replay reasoning from stored payloads (Responses) emit a plaintext item for
+ * it instead. Symbol-keyed so the marker never persists or reaches the wire.
+ */
+export declare const kCarriedReasoning: unique symbol;
+/** Carries the carried-reasoning marker without exposing a string-keyed property. */
+export type CarriedReasoningCarrier = object & {
+    [kCarriedReasoning]?: boolean;
+};
+/** True for thinking blocks carried natively from another host of the same model. */
+export declare function isCarriedReasoning(block: CarriedReasoningCarrier | null | undefined): boolean;
 /**
  * Marks an Anthropic wire message that was serialized from a source
  * `role: "user"` message.