@oh-my-pi/pi-ai 16.3.15 → 16.4.1

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [16.4.1] - 2026-07-10
+
+### Changed
+
+- Enforced `all_turns` reasoning context for all Responses Lite requests
+
+## [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

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,7 +2,7 @@ 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";
@@ -11,14 +11,19 @@ export interface ReasoningConfig {
     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. */
+    /** Explicit `reasoning.context` override; defaults to `all_turns` when unset. Gated to gpt-5.4+ Codex models (older ids reject it, so it is suppressed and `context` omitted). Note that under Responses Lite (`responsesLite`), the server strictly requires `reasoning.context` to be `all_turns`, which overrides this option and forces `all_turns`. */
     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 {
@@ -30,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;
@@ -39,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";
@@ -52,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,6 +6006,7 @@ 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;
     /**
@@ -6036,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
@@ -6047,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

@@ -224,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";
@@ -395,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/registry.d.ts

@@ -165,6 +165,10 @@ declare const ALL: ({
     readonly id: "nanogpt";
     readonly name: "NanoGPT";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    id: "novita";
+    name: string;
+    login: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 } | {
     readonly id: "nvidia";
     readonly name: "NVIDIA";

package/dist/types/types.d.ts

@@ -166,6 +166,27 @@ export interface RawSseEvent {
     data: string;
     raw: string[];
 }
+/** Lifecycle fields shared by every Codex compaction implementation. */
+export interface CodexCompactionContext {
+    /** Stable only for one logical compaction, including parallel summary calls. */
+    operationId: string;
+    trigger: "manual" | "auto";
+    reason: "user_requested" | "context_limit" | "model_downshift" | "comp_hash_changed";
+    phase: "standalone_turn" | "pre_turn" | "mid_turn";
+    strategy: "memento" | "prefix_compaction";
+}
+/** Canonical nested metadata serialized into the Codex turn envelope. */
+export interface CodexCompactionMetadata {
+    trigger: "manual" | "auto";
+    reason: "user_requested" | "context_limit" | "model_downshift" | "comp_hash_changed";
+    implementation: "responses" | "responses_compaction_v2" | "responses_compact";
+    phase: "standalone_turn" | "pre_turn" | "mid_turn";
+    strategy: "memento" | "prefix_compaction";
+}
+/** Dispatch context combining canonical metadata with its local operation identity. */
+export interface CodexCompactionRequestContext extends CodexCompactionMetadata {
+    operationId: string;
+}
 export interface StreamOptions {
     temperature?: number;
     topP?: number;
@@ -241,6 +262,8 @@ export interface StreamOptions {
      * Providers can use this to persist transport/session state between turns.
      */
     providerSessionState?: Map<string, ProviderSessionState>;
+    /** Canonical Codex compaction classification; ignored by other providers. */
+    codexCompaction?: CodexCompactionRequestContext;
     /**
      * Force Gemini model-mode Interactions API transport for providers that support it.
      * When unset, those providers may still use Interactions to continue known

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.3.15",
+	"version": "16.4.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.3.15",
-		"@oh-my-pi/pi-utils": "16.3.15",
-		"@oh-my-pi/pi-wire": "16.3.15",
+		"@oh-my-pi/pi-catalog": "16.4.1",
+		"@oh-my-pi/pi-utils": "16.4.1",
+		"@oh-my-pi/pi-wire": "16.4.1",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},