@oh-my-pi/pi-ai 16.3.14 → 16.4.0

package/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 ## [Unreleased]
 
+## [16.4.0] - 2026-07-10
+
+### Added
+
+- Added "max" as a first-class reasoning effort option across providers (including Anthropic, Google, Bedrock, and OpenAI), supporting a maximum reasoning budget of 32,768 tokens.
+- Added and standardized the "Responses Lite" wire contract and transport, enabling automatic activation via model-level catalog flags, moving tools and instructions into developer input items, disabling parallel tool calls, and stripping image detail instead of falling back to the full transport.
+- Added support for concurrent reasoning summaries on Codex Responses using the sequential-cutoff streaming contract.
+- Added Novita API-key login with authenticated key validation and automatic NOVITA_API_KEY environment variable discovery.
+
+### Changed
+
+- Recognized Pro Lite as a paid plan tier for OpenAI Codex models.
+
+### Fixed
+
+- Fixed xAI SuperGrok multi-account rotation to correctly treat HTTP 403 credit exhaustion and spending limit errors as usage limits, triggering a credential rotation to a sibling account.
+- Fixed error classification for AWS credential-resolution failures (AwsCredentialsError) to correctly map them as authentication failures.
+- Fixed OpenAI-compatible chat-completions streams to preserve vLLM-style trailing cached-token usage chunks, ensuring accurate cacheRead and billable input session statistics.
+- Fixed xai-oauth/grok-4.5 Responses requests to omit the unsupported reasoning.summary field while preserving the reasoning.effort payload.
+- Fixed Codex OAuth credential selection to re-check blocked accounts during ranking and clear stale usage-limit blocks once live usage indicates recovery.
+- Fixed sequential-cutoff reasoning summaries duplicating section headers across Codex reasoning items by tracking the cumulative summary response-globally, so replayed sections and replay-only items no longer re-emit text earlier thinking blocks already streamed.
+
+## [16.3.15] - 2026-07-09
+
+### Breaking Changes
+
+- Renamed `OpenAIResponsesCacheOptions`, `normalizeOpenAIResponsesPromptCacheKey`, and `getOpenAIResponsesPromptCacheKey` to the endpoint-neutral `OpenAICacheOptions`, `normalizeOpenAIPromptCacheKey`, and `getOpenAIPromptCacheKey`.
+
+### Added
+
+- Added automatic prompt-cache affinity header injection for OpenAI-family chat completions
+- Added support for explicit prompt-cache affinity headers in OpenAI-family chat completions
+- Added OpenAI pro reasoning mode support: models carrying the catalog `reasoningMode: "pro"` marker (GPT-5.6 Pro aliases) send `reasoning: { mode: "pro" }` on OpenAI Responses and Codex Responses requests, alongside the configured effort. The Codex request body now honors `requestModelId` so catalog aliases request the base upstream model id.
+
+### Changed
+
+- Updated xAI OAuth to use a dedicated device-code flow instead of redirect/loopback server
+
+### Fixed
+
+- Improved account routing for GPT-5.6 models to better respect paid tier requirements
+- Refined account selection logic to correctly identify plan types from account metadata
+- Fixed OpenAI Codex multi-account routing for GPT-5.6: Sol and Luna requests now prefer Plus-or-higher accounts while Terra remains available to Free/Go accounts; local pro-mode aliases inherit their base model's Codex plan eligibility.
+- Fixed xAI Grok OAuth login to use xAI's device authorization flow: `/login` now opens the verification URL, displays the device code, and polls for approval instead of asking for a pasted redirect or linking to Hermes Agent documentation.
+
 ## [16.3.14] - 2026-07-09
 
 ### Changed

package/README.md

@@ -59,6 +59,7 @@ Unified LLM API with automatic model discovery, provider configuration, token an
 - **Qianfan** (requires `QIANFAN_API_KEY`)
 - **NVIDIA** (requires `NVIDIA_API_KEY`)
 - **NanoGPT** (requires `NANO_GPT_API_KEY`)
+- **Novita** (requires `NOVITA_API_KEY`)
 - **Hugging Face Inference**
 - **xAI**
 - **Venice** (requires `VENICE_API_KEY`)
@@ -943,6 +944,7 @@ In Node.js environments, you can set environment variables to avoid passing API
 | Synthetic      | `SYNTHETIC_API_KEY`                                                          |
 | NVIDIA         | `NVIDIA_API_KEY`                                                             |
 | NanoGPT        | `NANO_GPT_API_KEY`                                                          |
+| Novita         | `NOVITA_API_KEY`                                                           |
 | Venice         | `VENICE_API_KEY`                                                             |
 | Moonshot       | `MOONSHOT_API_KEY`                                                           |
 | xAI            | `XAI_API_KEY`                                                                |
@@ -981,6 +983,7 @@ Provider endpoint defaults for the current OpenAI-compatible integrations:
 - Qianfan: `https://qianfan.baidubce.com/v2`
 - NVIDIA: `https://integrate.api.nvidia.com/v1`
 - NanoGPT: `https://nano-gpt.com/api/v1`
+- Novita: `https://api.novita.ai/openai/v1`
 - Hugging Face Inference: `https://router.huggingface.co/v1`
 - Venice: `https://api.venice.ai/api/v1`
 - Xiaomi MiMo: `https://api.xiaomimimo.com/anthropic`
@@ -1082,7 +1085,7 @@ Credentials are saved to `agent.db` in the agent directory. `/login qianfan` ope
 
 `login` supports OAuth providers (Anthropic, OpenAI Codex, GitHub Copilot, Gemini CLI, Antigravity) and API-key onboarding flows.
 
-For the current API-key onboarding flows, the library covers Together, Moonshot, Qianfan, NVIDIA, NanoGPT, Hugging Face, Venice, Xiaomi, vLLM, LiteLLM, Cloudflare AI Gateway, Qwen Portal, and Ollama Cloud. Ollama remains the local runtime integration; set `OLLAMA_API_KEY` only when your local or self-hosted deployment enforces bearer auth.
+For the current API-key onboarding flows, the library covers Together, Moonshot, Qianfan, NVIDIA, NanoGPT, Novita, Hugging Face, Venice, Xiaomi, vLLM, LiteLLM, Cloudflare AI Gateway, Qwen Portal, and Ollama Cloud. Ollama remains the local runtime integration; set `OLLAMA_API_KEY` only when your local or self-hosted deployment enforces bearer auth.
 
 ### Programmatic OAuth
 
@@ -1114,7 +1117,7 @@ import {
 	getOAuthApiKey, // (provider, credentialsMap) => { newCredentials, apiKey } | null
 
 	// Types
-	type OAuthProvider, // includes 'anthropic', 'openai-codex', 'github-copilot', 'google-gemini-cli', 'google-antigravity', 'together', 'moonshot', 'qianfan', 'nvidia', 'nanogpt', 'huggingface', 'venice', 'xiaomi', 'vllm', 'litellm', 'cloudflare-ai-gateway', 'qwen-portal', ...
+	type OAuthProvider, // includes 'anthropic', 'openai-codex', 'github-copilot', 'google-gemini-cli', 'google-antigravity', 'together', 'moonshot', 'qianfan', 'nvidia', 'nanogpt', 'novita', 'huggingface', 'venice', 'xiaomi', 'vllm', 'litellm', 'cloudflare-ai-gateway', 'qwen-portal', ...
 	type OAuthCredentials,
 } from "@oh-my-pi/pi-ai";
 ```

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

@@ -31,6 +31,7 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     refreshSnapshot(): Promise<SnapshotResponse>;
     listAuthCredentials(provider?: string): StoredAuthCredential[];
     getCredentialBlock(credentialId: number, providerKey: string, blockScope: string): number | undefined;
+    getCredentialBlockReconcileAfter(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     listCredentialBlocks(credentialIds: readonly number[]): StoredCredentialBlock[];
     upsertCredentialBlock(block: StoredCredentialBlock): void;
     deleteCredentialBlocks(credentialId: number): void;

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

@@ -79,6 +79,7 @@ export declare const credentialBlockSnapshotSchema: import("arktype/internal/var
     providerKey: string;
     blockScope: string;
     blockedUntilMs: number;
+    updatedAtMs?: number | undefined;
 }, {}>;
 export declare const snapshotEntrySchema: import("arktype/internal/variants/object.ts").ObjectType<{
     id: number;
@@ -103,6 +104,7 @@ export declare const snapshotEntrySchema: import("arktype/internal/variants/obje
         providerKey: string;
         blockScope: string;
         blockedUntilMs: number;
+        updatedAtMs?: number | undefined;
     }[] | undefined;
 }, {}>;
 export declare const refresherScheduleSchema: import("arktype/internal/variants/object.ts").ObjectType<{
@@ -144,6 +146,7 @@ export declare const snapshotResponseSchema: import("arktype/internal/variants/o
             providerKey: string;
             blockScope: string;
             blockedUntilMs: number;
+            updatedAtMs?: number | undefined;
         }[] | undefined;
     }[];
 }, {}>;
@@ -181,6 +184,7 @@ export declare const snapshotStreamSnapshotEventSchema: import("arktype/internal
             providerKey: string;
             blockScope: string;
             blockedUntilMs: number;
+            updatedAtMs?: number | undefined;
         }[] | undefined;
     }[];
     kind: "snapshot";
@@ -219,6 +223,7 @@ export declare const snapshotStreamEntryEventSchema: import("arktype/internal/va
             providerKey: string;
             blockScope: string;
             blockedUntilMs: number;
+            updatedAtMs?: number | undefined;
         }[] | undefined;
     };
 }, {}>;
@@ -269,6 +274,7 @@ export declare const snapshotStreamEventSchema: import("arktype/internal/variant
             providerKey: string;
             blockScope: string;
             blockedUntilMs: number;
+            updatedAtMs?: number | undefined;
         }[] | undefined;
     }[];
     kind: "snapshot";
@@ -305,6 +311,7 @@ export declare const snapshotStreamEventSchema: import("arktype/internal/variant
             providerKey: string;
             blockScope: string;
             blockedUntilMs: number;
+            updatedAtMs?: number | undefined;
         }[] | undefined;
     };
 } | {
@@ -410,6 +417,7 @@ export declare const credentialBlockRequestSchema: import("arktype/internal/vari
     providerKey: string;
     blockScope: string;
     blockedUntilMs: number;
+    updatedAtMs?: number | undefined;
 }, {}>;
 export declare const credentialBlockResponseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     ok: boolean;

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

@@ -72,6 +72,8 @@ export interface StoredCredentialBlock {
     blockScope: string;
     /** Epoch milliseconds. */
     blockedUntilMs: number;
+    /** Last row update timestamp in epoch milliseconds, when provided by the backing store. */
+    updatedAtMs?: number;
 }
 /**
  * Per-credential health record returned by {@link AuthStorage.checkCredentials}.
@@ -241,6 +243,8 @@ export interface AuthCredentialStore {
     cleanExpiredCache(): void;
     /** Non-expired block for one (credential, providerKey, scope) key, or undefined. */
     getCredentialBlock?(credentialId: number, providerKey: string, blockScope: string): number | undefined;
+    /** Earliest time a shared-store block should be eligible for live-usage reconciliation. */
+    getCredentialBlockReconcileAfter?(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     /** Upsert with MAX semantics: keep the later blockedUntilMs on conflict. */
     upsertCredentialBlock?(block: StoredCredentialBlock): void;
     /** Drop every block row for a credential (all providerKeys/scopes). */
@@ -1036,6 +1040,7 @@ export declare class SqliteAuthCredentialStore implements AuthCredentialStore {
     setCache(key: string, value: string, expiresAtSec: number): void;
     cleanExpiredCache(): void;
     getCredentialBlock(credentialId: number, providerKey: string, blockScope: string): number | undefined;
+    getCredentialBlockReconcileAfter(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     upsertCredentialBlock(block: StoredCredentialBlock): void;
     deleteCredentialBlocks(credentialId: number): void;
     cleanExpiredCredentialBlocks(nowMs: number): void;

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

@@ -1,7 +1,7 @@
 import type { ServiceTier, StreamFunction, StreamOptions, ToolChoice } from "../types.js";
 export { parseAzureDeploymentNameMap } from "./openai-shared.js";
 export interface AzureOpenAIResponsesOptions extends StreamOptions {
-    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     reasoningSummary?: "auto" | "detailed" | "concise" | null;
     azureApiVersion?: string;
     azureResourceName?: string;

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

@@ -1,6 +1,6 @@
 import type { StreamFunction, StreamOptions, ToolChoice } from "../types.js";
 export interface OllamaChatOptions extends StreamOptions {
-    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     disableReasoning?: boolean;
     toolChoice?: ToolChoice;
 }

package/dist/types/providers/openai-chat-server-schema.d.ts

@@ -665,7 +665,7 @@ export declare const openaiChatRequestSchema: import("arktype/internal/variants/
         [x: string]: number;
     } | undefined;
     user?: string | undefined;
-    reasoning_effort?: "high" | "low" | "medium" | "minimal" | "xhigh" | undefined;
+    reasoning_effort?: "high" | "low" | "max" | "medium" | "minimal" | "xhigh" | undefined;
     parallel_tool_calls?: boolean | undefined;
     service_tier?: "auto" | "default" | "flex" | "priority" | "scale" | undefined;
     metadata?: {

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

@@ -31,7 +31,7 @@ export type Metadata = {
     [key: string]: string;
 };
 /** Constrains effort on reasoning for reasoning models. */
-export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | null;
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | null;
 /** JSON object response format (older JSON mode). */
 export interface ResponseFormatJSONObject {
     /** Always `json_object`. */

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

@@ -2,21 +2,28 @@ import type { Model } from "../../types.js";
 /** Reasoning replay scope for the Codex Responses API (`reasoning.context`). */
 export type CodexReasoningContext = "auto" | "current_turn" | "all_turns";
 /** User-facing effort levels accepted by Codex request options. */
-type CodexCallerEffort = "minimal" | "low" | "medium" | "high" | "xhigh";
+type CodexCallerEffort = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export interface ReasoningConfig {
     effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     summary?: "auto" | "concise" | "detailed";
     context?: CodexReasoningContext;
+    /** Pro reasoning serving mode (gpt-5.6+ catalog pro aliases). */
+    mode?: "pro";
 }
 export interface CodexRequestOptions {
-    /** User-facing effort; the wire-only `max` tier is reached via the model's effort map. */
+    /** User-facing effort; maps 1:1 onto the wire tier of the same name. */
     reasoningEffort?: CodexCallerEffort | "none";
     reasoningSummary?: ReasoningConfig["summary"] | null;
     /** Explicit `reasoning.context` override; 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[];
-    /** Responses Lite transport contract: strips image detail and disables parallel tool calling, mirroring codex-rs. */
+    /**
+     * Responses Lite transport override; defaults to the model's
+     * `useResponsesLite`. Lite moves instructions/tools into input items,
+     * strips image detail, and disables parallel tool calling (codex-rs
+     * `use_responses_lite`).
+     */
     responsesLite?: boolean;
 }
 export interface InputItem {
@@ -28,6 +35,8 @@ export interface InputItem {
     name?: string;
     output?: unknown;
     arguments?: unknown;
+    /** `additional_tools` developer item payload (Responses Lite). */
+    tools?: unknown;
 }
 export interface RequestBody {
     model: string;
@@ -37,6 +46,10 @@ export interface RequestBody {
     input?: InputItem[];
     tools?: unknown;
     tool_choice?: unknown;
+    /** Concurrent reasoning-summary delivery (codex-rs `StreamOptions`). */
+    stream_options?: {
+        reasoning_summary_delivery: "sequential_cutoff";
+    };
     reasoning?: Partial<ReasoningConfig>;
     text?: {
         verbosity?: "low" | "medium" | "high";
@@ -50,8 +63,33 @@ export interface RequestBody {
     service_tier?: "auto" | "default" | "flex" | "scale" | "priority" | null;
     [key: string]: unknown;
 }
-/** Returns whether a Codex request can use the text-only Responses Lite transport. */
-export declare function shouldUseCodexResponsesLite(body: RequestBody, requested: boolean | undefined): boolean;
+/**
+ * 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.
+ */
+export declare function resolveCodexResponsesLite(model: Model<"openai-codex-responses">, requested: boolean | undefined): boolean;
+/**
+ * Structural view of a Responses-style body mutated by the Lite rewrite.
+ * Loose (`unknown`) property types let the turn transformer (`RequestBody`)
+ * and the agent's remote-compaction payloads reuse one shaper.
+ */
+export interface CodexLiteShapedBody {
+    instructions?: unknown;
+    tools?: unknown;
+    input?: unknown;
+    parallel_tool_calls?: unknown;
+}
+/**
+ * Applies the Responses Lite body contract in place (codex-rs
+ * `build_responses_request` with `use_responses_lite`): strips pinned image
+ * detail, forces parallel tool calling off, moves tools into a leading
+ * `additional_tools` developer item and the base instructions into a
+ * developer message, then omits top-level `instructions`/`tools`. Shared by
+ * normal turns and both remote-compaction paths — codex-rs routes
+ * `/responses/compact` through the same builder.
+ */
+export declare function applyCodexResponsesLiteShape(body: CodexLiteShapedBody): void;
 export declare function transformRequestBody(body: RequestBody, model: Model<"openai-codex-responses">, options?: CodexRequestOptions, prompt?: {
     developerMessages: string[];
 }): Promise<RequestBody>;

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

@@ -1,8 +1,8 @@
-import type { Context, Model, ProviderSessionState, ServiceTier, StreamFunction, StreamOptions, Tool, ToolChoice } from "../types.js";
+import type { CodexCompactionContext, CodexCompactionRequestContext, Context, Model, ProviderSessionState, ServiceTier, StreamFunction, StreamOptions, Tool, ToolChoice } from "../types.js";
 import { type CodexReasoningContext, type RequestBody } from "./openai-codex/request-transformer.js";
 import type { ResponseInput } from "./openai-responses-wire.js";
 export interface OpenAICodexResponsesOptions extends StreamOptions {
-    reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     reasoningSummary?: "auto" | "concise" | "detailed" | null;
     /** `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;
@@ -13,17 +13,19 @@ export interface OpenAICodexResponsesOptions extends StreamOptions {
     preferWebsockets?: boolean;
     serviceTier?: ServiceTier;
     /**
-     * Opt into the Responses Lite transport contract. Sends
+     * Responses Lite transport override; defaults to the model's catalog
+     * `useResponsesLite` flag (codex-rs `use_responses_lite`). Sends
      * `x-openai-internal-codex-responses-lite: true` on HTTP requests and on the
      * WebSocket upgrade (the marker is connection-scoped there, so lite and
-     * non-lite turns never share a pooled socket), strips image detail from
-     * input, and disables parallel tool calling — mirroring codex-rs.
+     * non-lite turns never share a pooled socket), moves instructions/tools
+     * into input items, strips image detail, and disables parallel tool
+     * calling — mirroring codex-rs.
      */
     responsesLite?: boolean;
     /**
-     * Extra `client_metadata` to include in the request body on both transports.
-     * The canonical Codex envelope is `client_metadata["x-codex-turn-metadata"]`
-     * (JSON string of thread/turn identifiers); flat keys are also accepted.
+     * Additional fields embedded in the canonical
+     * `client_metadata["x-codex-turn-metadata"]` JSON blob. Reserved identity
+     * keys are ignored; extras are never emitted as top-level metadata fields.
      */
     clientMetadata?: Record<string, string>;
     /**
@@ -34,6 +36,34 @@ export interface OpenAICodexResponsesOptions extends StreamOptions {
      */
     onModerationMetadata?: (metadata: unknown) => void;
 }
+/** Inputs for synthesizing Codex request identity outside the normal stream path. */
+export interface OpenAICodexCompatibilityMetadataOptions {
+    sessionId?: string;
+    providerSessionState?: Map<string, ProviderSessionState>;
+    requestKind: OpenAICodexRequestKind;
+    compaction?: CodexCompactionRequestContext;
+    startNewTurn?: boolean;
+    turnStartedAtUnixMs?: number;
+    clientMetadata?: Readonly<Record<string, string>>;
+    /** Add the direct installation header required by `/responses/compact`. */
+    includeInstallationHeader?: boolean;
+}
+/** Canonical Codex body metadata and compatibility headers for one request. */
+export interface OpenAICodexCompatibilityMetadata {
+    clientMetadata: Record<string, string>;
+    headers: Record<string, string>;
+}
+/** Live Codex session state to preserve after a successful history rewrite. */
+export interface OpenAICodexCompactionResetOptions {
+    providerSessionState?: Map<string, ProviderSessionState>;
+    sessionId?: string;
+    compaction: CodexCompactionContext;
+}
+/** Add the selected wire implementation to one logical compaction context. */
+export declare function createOpenAICodexCompactionRequestContext(options: {
+    context: CodexCompactionContext | undefined;
+    implementation: "responses" | "responses_compaction_v2" | "responses_compact";
+}): CodexCompactionRequestContext | undefined;
 type CodexTransport = "sse" | "websocket";
 /** Shape of the Codex request sent on the latest provider turn. */
 export interface OpenAICodexTurnRequestDiagnostics {
@@ -84,6 +114,18 @@ export interface OpenAICodexWebSocketDebugStats {
     lastPreviousResponseId?: string;
     lastTurn?: OpenAICodexTurnDiagnostics;
 }
+/** Request classification encoded in Codex turn metadata. */
+export type OpenAICodexRequestKind = "turn" | "prewarm" | "compaction";
+/**
+ * Synthesize Codex request identity for raw provider routes such as remote
+ * compaction while reusing the live session's thread, window, and turn.
+ */
+export declare function createOpenAICodexCompatibilityMetadata(options: OpenAICodexCompatibilityMetadataOptions): OpenAICodexCompatibilityMetadata;
+/**
+ * Invalidate Codex history-dependent transport state after compaction while
+ * retaining the session identity and live connection.
+ */
+export declare function resetOpenAICodexHistoryAfterCompaction(options: OpenAICodexCompactionResetOptions): void;
 /** @internal Exported for tests. */
 export declare function normalizeCodexToolChoice(choice: ToolChoice | undefined, tools?: Tool[], model?: Model<"openai-codex-responses">): string | Record<string, unknown> | undefined;
 /** @internal Exported for tests. */
@@ -99,6 +141,7 @@ export interface OpenAICodexTransportDetails {
     canAppend: boolean;
     prewarmed: boolean;
     hasSessionState: boolean;
+    hasTurnState: boolean;
     lastFallbackAt?: number;
 }
 export declare function getOpenAICodexWebSocketDebugStats(model: Model<"openai-codex-responses">, options?: {

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

@@ -18,7 +18,7 @@ export { applyOpenRouterRoutingVariant } from "./openai-shared.js";
 export declare function isOpenAICompletionsProgressChunk(chunk: unknown): boolean;
 export interface OpenAICompletionsOptions extends StreamOptions {
     toolChoice?: ToolChoice;
-    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     /** Force-disable reasoning where supported, or request the lowest effort on generic effort endpoints. */
     disableReasoning?: boolean;
     serviceTier?: ServiceTier;

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

@@ -5995,9 +5995,9 @@ export interface Reasoning {
     /**
      * Constrains effort on reasoning for
      * [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-     * supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
-     * Reducing reasoning effort can result in faster responses and fewer tokens used
-     * on reasoning in a response.
+     * supported values are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and
+     * `max`. Reducing reasoning effort can result in faster responses and fewer
+     * tokens used on reasoning in a response.
      *
      * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
      *   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
@@ -6006,8 +6006,16 @@ export interface Reasoning {
      *   support `none`.
      * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
      * - `xhigh` is supported for all models after `gpt-5.1-codex-max`.
+     * - `max` is supported for `gpt-5.6` and later models.
      */
     effort?: ReasoningEffort | null;
+    /**
+     * **gpt-5.6 and later models only**
+     *
+     * Reasoning serving mode. `pro` routes the request to the pro reasoning
+     * path (more compute per response); omit for the standard path.
+     */
+    mode?: "pro" | null;
     /**
      * @deprecated **Deprecated:** use `summary` instead.
      *
@@ -6029,9 +6037,9 @@ export interface Reasoning {
 /**
  * Constrains effort on reasoning for
  * [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
- * supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
- * Reducing reasoning effort can result in faster responses and fewer tokens used
- * on reasoning in a response.
+ * supported values are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and
+ * `max`. Reducing reasoning effort can result in faster responses and fewer tokens
+ * used on reasoning in a response.
  *
  * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
  *   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
@@ -6040,8 +6048,9 @@ export interface Reasoning {
  *   support `none`.
  * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
  * - `xhigh` is supported for all models after `gpt-5.1-codex-max`.
+ * - `max` is supported for `gpt-5.6` and later models.
  */
-export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | null;
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | null;
 /**
  * JSON object response format. An older method of generating JSON responses. Using
  * `json_schema` is recommended for models that support it. Note that the model

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

@@ -4,7 +4,7 @@ import { type OpenAIReasoningEffortFallbackState } from "./openai-reasoning-fall
 import type { Tool as OpenAITool, ResponseCreateParamsStreaming, ResponseInput } from "./openai-responses-wire.js";
 import { type OpenAIStrictToolsScope, type OpenAIStrictToolsState } from "./openai-shared.js";
 export interface OpenAIResponsesOptions extends StreamOptions {
-    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     reasoningSummary?: "auto" | "detailed" | "concise" | null;
     serviceTier?: ServiceTier;
     textVerbosity?: "low" | "medium" | "high";

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

@@ -27,7 +27,8 @@ export interface OpenAIRequestSetupModel extends OpenAIModelIdentity {
     premiumMultiplier?: number;
     compat?: Pick<ResolvedOpenAISharedCompat, "promptCacheSessionHeader">;
 }
-export interface OpenAIResponsesCacheOptions {
+/** Cache identity controls shared by OpenAI-family transports. */
+export interface OpenAICacheOptions {
     cacheRetention?: CacheRetention;
     sessionId?: string;
     promptCacheKey?: string;
@@ -86,11 +87,13 @@ export interface OpenAIUsageAccounting {
     orchestration?: Usage["orchestration"];
 }
 export declare function calculateOpenAIUsageAccounting(accounting: OpenAIUsageAccountingInput): OpenAIUsageAccounting;
-export declare function normalizeOpenAIResponsesPromptCacheKey(sessionId: string | undefined): string | undefined;
+/** Normalize a cache identity to the wire limit accepted by OpenAI-family providers. */
+export declare function normalizeOpenAIPromptCacheKey(sessionId: string | undefined): string | undefined;
 export declare function normalizeOpenRouterResponsesSessionId(sessionId: string | undefined): string | undefined;
-export declare function getOpenAIResponsesPromptCacheKey(options: OpenAIResponsesCacheOptions | undefined): string | undefined;
-export declare function getOpenAIResponsesRoutingSessionId(options: Pick<OpenAIResponsesCacheOptions, "cacheRetention" | "sessionId"> | undefined): string | undefined;
-export declare function getOpenRouterResponsesSessionId(options: Pick<OpenAIResponsesCacheOptions, "cacheRetention" | "sessionId"> | undefined): string | undefined;
+/** Resolve a prompt-cache identity, falling back to the provider session unless caching is disabled. */
+export declare function getOpenAIPromptCacheKey(options: OpenAICacheOptions | undefined): string | undefined;
+export declare function getOpenAIResponsesRoutingSessionId(options: Pick<OpenAICacheOptions, "cacheRetention" | "sessionId"> | undefined): string | undefined;
+export declare function getOpenRouterResponsesSessionId(options: Pick<OpenAICacheOptions, "cacheRetention" | "sessionId"> | undefined): string | undefined;
 export declare function parseAzureDeploymentNameMap(value: string | undefined): Map<string, string>;
 export declare function createOpenAIStrictToolsState(): OpenAIStrictToolsState;
 export declare function clearOpenAIStrictToolsState(state: OpenAIStrictToolsState): void;
@@ -221,7 +224,7 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
 };
 /** Reasoning-relevant slice of caller options the Chat Completions dialect dispatch reads. */
 export interface ChatCompletionsReasoningOptions {
-    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     disableReasoning?: boolean;
 }
 export type OpenAICompatEndpoint = "chat-completions" | "responses";
@@ -392,10 +395,37 @@ type ResponsesToolCallBlock = ToolCall & {
     [kStreamingLastParseLen]?: number;
 };
 export declare function appendReasoningSummaryPart(item: ResponseReasoningItem, part: ResponseReasoningItem["summary"][number]): void;
-/** Chooses the final reasoning text without discarding content already streamed into the block. */
-export declare function finalizeReasoningThinking(item: ResponseReasoningItem, streamedThinking: string): string;
+/**
+ * Response-global accumulator for the sequential-cutoff summary contract.
+ *
+ * Summary indices are cumulative across ALL reasoning items in a response:
+ * each new reasoning item replays the previous item's last completed section
+ * (`.done` at index N-1) before streaming its own, and replay-only items may
+ * add nothing new. Folding per item would re-emit every replayed section, so
+ * the canonical summary and the emitted text span items and live here.
+ */
+export interface SequentialCutoffSummaryState {
+    /** Latest full text per response-global summary index. */
+    summary: ResponseReasoningItem["summary"];
+    /** Canonical summary text already emitted as thinking deltas across all blocks. */
+    emitted: string;
+}
+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;
 export declare function appendReasoningSummaryTextDelta(item: ResponseReasoningItem, block: ThinkingContent, delta: string, 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.
+ *
+ * Sequential-cutoff summary indices are response-global: later reasoning items
+ * replay earlier sections, resend the accumulated summary as one part, or
+ * complete without new sections. The canonical summary is rebuilt in `state`
+ * (spanning items) and only its append-only suffix is emitted into the current
+ * block. Divergent corrections stay buffered until finalization so delta
+ * consumers never receive suffixes based on unseen replacement text.
+ */
+export declare function applyReasoningSummaryDone(state: SequentialCutoffSummaryState, block: ThinkingContent, text: string, summaryIndex: number, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number): void;
 export declare function appendMessageContentPart(item: ResponseOutputMessage, part: ResponseContentPartAddedEvent["part"] | undefined): void;
 export declare function appendMessageTextDelta(item: ResponseOutputMessage, block: TextContent, delta: string, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number, partType: "output_text" | "refusal"): void;
 export declare function accumulateToolCallArgumentsDelta(block: ResponsesToolCallBlock, delta: string, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number): void;

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

@@ -0,0 +1,6 @@
+export declare const loginNovita: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+export declare const novitaProvider: {
+    id: "novita";
+    name: string;
+    login: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+};

package/dist/types/registry/oauth/device-code.d.ts

@@ -0,0 +1,25 @@
+/** Result returned by one OAuth device-code polling attempt. */
+export type OAuthDeviceCodePollResult<T> = {
+    status: "complete";
+    value: T;
+} | {
+    status: "pending";
+} | {
+    status: "slow_down";
+} | {
+    status: "failed";
+    message: string;
+};
+/** Options for polling an RFC 8628-style OAuth device-code flow. */
+export interface OAuthDeviceCodeFlowOptions<T> {
+    /** Poll the provider once and classify the response. */
+    poll(): OAuthDeviceCodePollResult<T> | Promise<OAuthDeviceCodePollResult<T>>;
+    /** Provider-requested polling cadence; defaults to RFC 8628's five seconds. */
+    intervalSeconds?: number;
+    /** Provider-issued expiry window for the device code. */
+    expiresInSeconds?: number;
+    /** Cancels the flow with the legacy "Login cancelled" error. */
+    signal?: AbortSignal;
+}
+/** Poll an OAuth device-code flow until completion, provider failure, timeout, or cancellation. */
+export declare function pollOAuthDeviceCodeFlow<T>(options: OAuthDeviceCodeFlowOptions<T>): Promise<T>;

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

@@ -1,30 +1,6 @@
 import type { OAuthCredentials, OAuthProvider, OAuthProviderId, OAuthProviderInfo, OAuthProviderInterface } from "./types.js";
+export * from "./device-code.js";
 export type * from "./types.js";
-/** Result returned by one OAuth device-code polling attempt. */
-export type OAuthDeviceCodePollResult<T> = {
-    status: "complete";
-    value: T;
-} | {
-    status: "pending";
-} | {
-    status: "slow_down";
-} | {
-    status: "failed";
-    message: string;
-};
-/** Options for polling an RFC 8628-style OAuth device-code flow. */
-export interface OAuthDeviceCodeFlowOptions<T> {
-    /** Poll the provider once and classify the response. */
-    poll(): OAuthDeviceCodePollResult<T> | Promise<OAuthDeviceCodePollResult<T>>;
-    /** Provider-requested polling cadence; defaults to RFC 8628's five seconds. */
-    intervalSeconds?: number;
-    /** Provider-issued expiry window for the device code. */
-    expiresInSeconds?: number;
-    /** Cancels the flow with the legacy "Login cancelled" error. */
-    signal?: AbortSignal;
-}
-/** Poll an OAuth device-code flow until completion, provider failure, timeout, or cancellation. */
-export declare function pollOAuthDeviceCodeFlow<T>(options: OAuthDeviceCodeFlowOptions<T>): Promise<T>;
 /**
  * Register a custom OAuth provider.
  */