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

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+### Fixed
+
+- Fixed stateful OpenAI Responses explicit cache breakpoints being restored onto edited historical messages, ensuring full replays recompute the latest stable cache boundary.
+
+## [17.1.0] - 2026-07-24
+
+### Added
+
+- Added support for caller-owned `cachedContent` on Google Generative AI and Google Vertex AI `GenerateContent` options, allowing passing of opaque cache resource names.
+- Added Anthropic extra-usage reporting across CLI, interactive, and ACP usage endpoints, normalizing the authoritative `spend` payload into a 'Claude Extra Usage' USD row with accurate limit, remaining, and status details.
+- Added process-scoped OAuth account pools for trusted auth-broker clients via `OMP_AUTH_BROKER_ACCOUNT_POOL_FILE` to filter snapshots, updates, refreshes, and usage reports to selected OAuth identities.
+- Added opt-in Vercel AI Gateway automatic prompt caching for OpenAI Chat Completions, including support for cache anchors and cache lifetimes.
+- Added opt-in explicit prompt-cache controls for OpenAI GPT-5.6+ Responses and Chat Completions, supporting stable boundary selection, stateful Responses markers, and future GPT-5.x/6.x models.
+- Added support for forwarding `statefulResponses` through `streamSimple` to allow diagnostic callers to explicitly disable OpenAI Responses `previous_response_id` chaining.
+- Added native QwenCloud Token Plan support, including API-key login, model discovery, and an optional interactive console-Cookie prompt for quota reporting.
+- Added interactive Meta Model API key login and support for `MODEL_API_KEY` and `META_API_KEY` environment variables.
+- Added model-scoped usage health tracking and same-provider reselection for native coding-plan credential pools.
+
+### Fixed
+
+- Fixed AWS Bedrock cache checkpoints to use resolved model compatibility, falling back to the provider-default 5-minute cache for unsupported 1-hour retentions, emitting AWS-recommended explicit checkpoints for Nova models (Lite, Micro, Pro, Premier, Nova 2 Lite), and honoring configured checkpoint maxima.
+- Fixed Pi-native and compatibility-wrapper requests dropping cache controls required by `omp bench --cache` to preserve explicit prompt-cache affinity and allow disabling OpenAI Responses chaining.
+- Fixed outbound credential-pattern redaction running unconditionally; it is now opt-in via `configureCredentialRedaction` and disabled by default.
+- Fixed SuperGrok (`xai-oauth`) `/usage` reporting for unified-billing accounts by falling back to the default monthly limit and usage payload when credit usage percentages are absent.
+- Fixed sessions wedging with a `400 Invalid signature in thinking block` error when switching Anthropic-compatible providers by stripping signatures whose issuing provider differs from the target.
+- Fixed OAuth callback servers aborting login on premature invalid callbacks, and restricted `localhost` callback listeners to the IPv4 loopback interface.
+- Fixed Google Gemini CLI and Antigravity OAuth login hanging indefinitely during Cloud Code Assist project provisioning by introducing request timeouts, cancellation checks, and bounded polling.
+
 ## [17.0.9] - 2026-07-23
 
 ### Added

package/README.md

@@ -73,6 +73,8 @@ Unified LLM API with automatic model discovery, provider configuration, token an
 - **Xiaomi MiMo** (requires `XIAOMI_API_KEY`)
 - **ZenMux** (requires `ZENMUX_API_KEY`)
 - **Qwen Portal** (supports `QWEN_OAUTH_TOKEN` or `QWEN_PORTAL_API_KEY`)
+- **QwenCloud Token Plan** (supports `/login alibaba-token-plan`, `ALIBABA_TOKEN_PLAN_API_KEY`, or `BAILIAN_TOKEN_PLAN_API_KEY`; interactive login optionally stores a `home.qwencloud.com` Cookie request header for best-effort 5-hour and 7-day quota reporting)
+  To enable quota reporting, sign in to the Token Plan dashboard, copy the `Cookie` request-header value from a `home.qwencloud.com` request in browser developer tools, and paste it at the second login prompt. Press Enter to skip; the Cookie is sensitive and session-lived, so rerun login when it expires.
 - **Cloudflare AI Gateway** (requires `CLOUDFLARE_AI_GATEWAY_API_KEY` and provider-specific gateway base URL)
 - **Ollama** (local OpenAI-compatible runtime; optional `OLLAMA_API_KEY`)
 - **Ollama Cloud** (hosted native Ollama API; requires `OLLAMA_CLOUD_API_KEY`)
@@ -953,6 +955,7 @@ In Node.js environments, you can set environment variables to avoid passing API
 | Ollama         | `OLLAMA_API_KEY` (optional for local deployments)                            |
 | Ollama Cloud   | `OLLAMA_CLOUD_API_KEY`                                                     |
 | Qwen Portal    | `QWEN_OAUTH_TOKEN` or `QWEN_PORTAL_API_KEY`                                  |
+| QwenCloud Token Plan | `ALIBABA_TOKEN_PLAN_API_KEY` or `BAILIAN_TOKEN_PLAN_API_KEY`                   |
 | zAI            | `ZAI_API_KEY`                                                                |
 | Umans AI Coding Plan | `UMANS_AI_CODING_PLAN_API_KEY`                                           |
 | MiniMax Code   | `MINIMAX_CODE_API_KEY` (international) or `MINIMAX_CODE_CN_API_KEY` (China) |

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

@@ -1,4 +1,5 @@
 import { AuthStorage } from "../auth-storage.js";
+import { type AuthBrokerAccountPool } from "./remote-store.js";
 export interface AuthBrokerClientConfig {
     url: string;
     token: string;
@@ -12,9 +13,12 @@ export interface DiscoverAuthStorageOptions {
     configValueResolver?: (config: string) => Promise<string | undefined>;
     cachePath?: string;
     sourceLabel?: string;
+    /** Programmatic pool for SDK hosts. Takes precedence over the environment file. */
+    accountPool?: AuthBrokerAccountPool;
 }
 /** Path to the local bearer token file. Created by `omp auth-broker token`. */
 export declare function getAuthBrokerTokenFilePath(): string;
+export declare function loadAuthBrokerAccountPool(): Promise<AuthBrokerAccountPool | undefined>;
 /**
  * Resolve broker connection configuration using the same precedence as the TUI:
  *

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

@@ -4,6 +4,12 @@ import type { Provider } from "../types.js";
 import type { UsageReport } from "../usage.js";
 import { type AuthBrokerClient } from "./client.js";
 import type { SnapshotResponse } from "./types.js";
+/**
+ * Per-provider OAuth identities visible to this trusted broker client.
+ * Missing providers are unrestricted; an empty set excludes that provider's
+ * OAuth credentials. API keys are never filtered.
+ */
+export type AuthBrokerAccountPool = ReadonlyMap<string, ReadonlySet<string>>;
 export interface RemoteAuthCredentialStoreOptions {
     client: AuthBrokerClient;
     /**
@@ -17,10 +23,16 @@ export interface RemoteAuthCredentialStoreOptions {
      */
     streamSnapshots?: boolean;
     /**
-     * Called after broker-sourced full snapshots are applied. The constructor's
-     * initial snapshot intentionally does not trigger this hook.
+     * Called with each broker-sourced raw full snapshot after the filtered
+     * public view is applied. The constructor's initial snapshot intentionally
+     * does not trigger this hook.
      */
     onSnapshot?: (snapshot: SnapshotResponse, generation: number) => void;
+    /**
+     * OAuth identities visible through this store. This is a trusted-client
+     * routing policy, not broker authorization.
+     */
+    accountPool?: AuthBrokerAccountPool;
 }
 export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     #private;

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

@@ -457,6 +457,27 @@ export interface UsageLimitMarkResult {
     switched: boolean;
     retryAtMs?: number;
 }
+export type ModelUsageHealthState = "healthy" | "reserve" | "depleted" | "unknown";
+export interface ModelUsageAccountHealth {
+    credentialId: number;
+    credentialType: AuthCredential["type"];
+    /** True when this credential is currently sticky for options.sessionId. */
+    selected?: true;
+    state: ModelUsageHealthState;
+    remainingFraction?: number;
+    resetsAt?: number;
+}
+export interface ModelUsageHealth {
+    state: ModelUsageHealthState;
+    accounts: ModelUsageAccountHealth[];
+}
+export interface ModelUsageHealthOptions {
+    modelId?: string;
+    sessionId?: string;
+    baseUrl?: string;
+    reserveFraction: number;
+    signal?: AbortSignal;
+}
 type AuthApiKeyOptions = {
     baseUrl?: string;
     modelId?: string;
@@ -825,6 +846,30 @@ export declare class AuthStorage {
      * providers without a usage API) — the latter never warrants a usage row.
      */
     usageProviderFor(provider: Provider): UsageProvider | undefined;
+    /**
+     * Return model ids whose live reports map to a quantitative usage scope.
+     * Provider strategies supply model/tier mapping when available; otherwise
+     * only explicitly matching model ids and account-wide shared limits count.
+     * Label-only or ambiguous tier limits are excluded rather than guessed.
+     */
+    getUsageReportingModelIds(provider: Provider, modelIds: readonly string[], reports: readonly UsageReport[]): string[];
+    /**
+     * Inspect the credential pool that {@link getApiKey} would use for one model
+     * without advancing round-robin state or changing session stickiness.
+     *
+     * Pool aggregation is deliberately conservative: one healthy sibling makes
+     * the model healthy, while any unknown sibling prevents a depleted/reserve
+     * conclusion. Static runtime/config/env credentials return unknown because
+     * they bypass the managed account pool.
+     */
+    getModelUsageHealth(provider: Provider, options: ModelUsageHealthOptions): Promise<ModelUsageHealth>;
+    /**
+     * Release a session's sticky credential so its next {@link getApiKey} call
+     * re-runs native pool ranking. This never blocks or penalizes the released
+     * account; usage-aware routing uses it when another sibling has more
+     * headroom, before considering a model/provider fallback.
+     */
+    releaseSessionCredentialForReselection(provider: string, sessionId: string): boolean;
     fetchUsageReports(options?: {
         baseUrlResolver?: (provider: Provider) => string | undefined;
         /** Caller's cancel signal; only rejects this caller, never the shared upstream fetch. */

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

@@ -37,6 +37,17 @@ export interface GoogleSharedStreamOptions extends StreamOptions {
     hideThinkingSummary?: boolean;
     /** Gemini/Vertex serving tier (`flex`/`priority`); other values are omitted. */
     serviceTier?: ServiceTier;
+    /**
+     * Caller-owned Google context-cache resource name for GenerateContent.
+     * Passed through opaquely as the wire `cachedContent` field on
+     * `google-generative-ai` and `google-vertex` only. OMP does not create,
+     * refresh, validate model/project/location compatibility, or delete the
+     * resource — callers own that lifecycle.
+     *
+     * @see https://ai.google.dev/api/generate-content
+     * @see `@google/genai` `GenerateContentConfig.cachedContent`
+     */
+    cachedContent?: string;
 }
 /**
  * Determines whether a streamed Gemini `Part` should be treated as "thinking".

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

@@ -99,12 +99,20 @@ export interface ChatCompletionContentPartText {
     text: string;
     /** Always `text`. */
     type: "text";
+    /** Explicit OpenAI prompt-cache breakpoint. */
+    prompt_cache_breakpoint?: {
+        mode: "explicit";
+    };
 }
 /** Image content part. */
 export interface ChatCompletionContentPartImage {
     image_url: ChatCompletionContentPartImageImageURL;
     /** Always `image_url`. */
     type: "image_url";
+    /** Explicit OpenAI prompt-cache breakpoint. */
+    prompt_cache_breakpoint?: {
+        mode: "explicit";
+    };
 }
 /** SDK `ChatCompletionContentPartImage.ImageURL`. */
 export interface ChatCompletionContentPartImageImageURL {
@@ -118,6 +126,10 @@ export interface ChatCompletionContentPartInputAudio {
     input_audio: ChatCompletionContentPartInputAudioInputAudio;
     /** Always `input_audio`. */
     type: "input_audio";
+    /** Explicit OpenAI prompt-cache breakpoint. */
+    prompt_cache_breakpoint?: {
+        mode: "explicit";
+    };
 }
 /** SDK `ChatCompletionContentPartInputAudio.InputAudio`. */
 export interface ChatCompletionContentPartInputAudioInputAudio {
@@ -131,6 +143,10 @@ export interface ChatCompletionContentPartFile {
     file: ChatCompletionContentPartFileFile;
     /** Always `file`. */
     type: "file";
+    /** Explicit OpenAI prompt-cache breakpoint. */
+    prompt_cache_breakpoint?: {
+        mode: "explicit";
+    };
 }
 /** SDK `ChatCompletionContentPart.File.File`. */
 export interface ChatCompletionContentPartFileFile {
@@ -147,6 +163,10 @@ export interface ChatCompletionContentPartRefusal {
     refusal: string;
     /** Always `refusal`. */
     type: "refusal";
+    /** Explicit OpenAI prompt-cache breakpoint. */
+    prompt_cache_breakpoint?: {
+        mode: "explicit";
+    };
 }
 /** User-message content part union. */
 export type ChatCompletionContentPart = ChatCompletionContentPartText | ChatCompletionContentPartImage | ChatCompletionContentPartInputAudio | ChatCompletionContentPartFile;
@@ -598,6 +618,11 @@ export interface ChatCompletionCreateParamsBase {
     prompt_cache_key?: string;
     /** Retention policy for the prompt cache; `24h` enables extended caching. */
     prompt_cache_retention?: "in_memory" | "24h" | null;
+    /** Explicit prompt-cache mode and minimum lifetime for GPT-5.6+ models. */
+    prompt_cache_options?: {
+        mode: "implicit" | "explicit";
+        ttl?: "30m";
+    };
     /** Constrains effort on reasoning for reasoning models. */
     reasoning_effort?: ReasoningEffort | null;
     /** Output format: text, JSON mode, or Structured Outputs JSON schema. */

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

@@ -1,6 +1,7 @@
 import type { ResolvedOpenAICompat } from "@oh-my-pi/pi-catalog/types";
 import type { AssistantMessage, Context, Model, ServiceTier, StreamFunction, StreamOptions, ToolChoice } from "../types.js";
 import type { ChatCompletionMessageParam } from "./openai-chat-wire.js";
+import { type OpenAIPromptCacheOptions } from "./openai-shared.js";
 export { applyOpenRouterRoutingVariant } from "./openai-shared.js";
 /**
  * Identify "real progress" stream chunks vs. keepalives, role-only preambles,
@@ -33,6 +34,8 @@ export interface OpenAICompletionsOptions extends StreamOptions {
      * with the variant baked in).
      */
     openrouterVariant?: string;
+    /** Opt-in GPT-5.6+ prompt-cache policy. Unsupported explicit mode fails locally. */
+    promptCache?: OpenAIPromptCacheOptions;
 }
 /**
  * Public entry: wrap the single-attempt streamer with bounded empty-completion

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

@@ -2815,6 +2815,10 @@ export interface ResponseInputFile {
      * The name of the file to be sent to the model.
      */
     filename?: string;
+    /** Explicit OpenAI prompt-cache breakpoint. */
+    prompt_cache_breakpoint?: {
+        mode: "explicit";
+    };
 }
 /**
  * A file input to the model.
@@ -2870,6 +2874,10 @@ export interface ResponseInputImage {
      * encoded image in a data URL.
      */
     image_url?: string | null;
+    /** Explicit OpenAI prompt-cache breakpoint. */
+    prompt_cache_breakpoint?: {
+        mode: "explicit";
+    };
 }
 /**
  * An image input to the model. Learn about
@@ -3543,6 +3551,10 @@ export interface ResponseInputText {
      * The type of the input item. Always `input_text`.
      */
     type: "input_text";
+    /** Explicit OpenAI prompt-cache breakpoint. */
+    prompt_cache_breakpoint?: {
+        mode: "explicit";
+    };
 }
 /**
  * A text input to the model.
@@ -5700,6 +5712,11 @@ export interface ResponseCreateParamsBase {
      *   `prompt_cache_retention` is not specified.
      */
     prompt_cache_retention?: "in_memory" | "24h" | null;
+    /** Explicit prompt-cache mode and minimum lifetime for GPT-5.6+ models. */
+    prompt_cache_options?: {
+        mode: "implicit" | "explicit";
+        ttl?: "30m";
+    } | null;
     /**
      * **gpt-5 and o-series models only**
      *

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

@@ -2,7 +2,7 @@ import type { Context, Model, OpenAICompat, ProviderSessionState, ServiceTier, S
 import { type OpenAIResponsesToolChoice } from "../utils/tool-choice.js";
 import { type OpenAIReasoningEffortFallbackState } from "./openai-reasoning-fallback.js";
 import type { Tool as OpenAITool, ResponseCreateParamsStreaming, ResponseInput } from "./openai-responses-wire.js";
-import { type OpenAIStrictToolsScope, type OpenAIStrictToolsState } from "./openai-shared.js";
+import { type OpenAIPromptCacheOptions, type OpenAIStrictToolsScope, type OpenAIStrictToolsState } from "./openai-shared.js";
 export interface OpenAIResponsesOptions extends StreamOptions {
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     reasoningSummary?: "auto" | "detailed" | "concise" | null;
@@ -56,6 +56,8 @@ export interface OpenAIResponsesOptions extends StreamOptions {
      * prompt_cache_key for prompt-cache routing).
      */
     extraBody?: Record<string, unknown>;
+    /** Opt-in GPT-5.6+ prompt-cache policy. Unsupported explicit mode fails locally. */
+    promptCache?: OpenAIPromptCacheOptions;
 }
 interface OpenAIResponsesProviderSessionState extends ProviderSessionState, OpenAIStrictToolsState, OpenAIReasoningEffortFallbackState {
     nativeHistoryReplayWarmed: boolean;
@@ -68,6 +70,7 @@ interface OpenAIResponsesChainState {
      * `previous_response_id`.
      */
     lastParams?: OpenAIResponsesSamplingParams;
+    lastPromptCacheBreakpointPolicy?: "latest-stable-message" | "none";
     lastResponseId?: string;
     /** Output items of the last response, in replay-sanitized form (matches next-turn input). */
     lastResponseItems?: ResponseInput;
@@ -98,6 +101,9 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
         enabled: false;
     };
     cache_control?: OpenRouterAnthropicCacheControl;
+    caching?: "auto";
+    cache_anchor_items?: number;
+    cache_ttl?: "5m" | "1h";
 };
 /**
  * Public entry: wrap the single-attempt Responses streamer with bounded
@@ -106,7 +112,7 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
  * Anthropic providers via `withEmptyCompletionRetry`.
  */
 export declare const streamOpenAIResponses: StreamFunction<"openai-responses">;
-export declare function buildParams(model: Model<"openai-responses">, context: Context, options: OpenAIResponsesOptions | undefined, providerSessionState: OpenAIResponsesProviderSessionState | undefined, strictToolsScope?: OpenAIStrictToolsScope, disableStrictToolsOverride?: boolean): {
+export declare function buildParams(model: Model<"openai-responses">, context: Context, options: OpenAIResponsesOptions | undefined, providerSessionState: OpenAIResponsesProviderSessionState | undefined, strictToolsScope?: OpenAIStrictToolsScope, disableStrictToolsOverride?: boolean, statefulCacheBaseline?: ResponseInput): {
     params: OpenAIResponsesSamplingParams;
     strictToolsApplied: boolean;
 };

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

@@ -1,6 +1,7 @@
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import type { OpenAICompat, OpenAIReasoningDisableMode, OpenAIStreamMarkupHealingPattern, OpenRouterRouting, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat, ResolvedOpenAISharedCompat, VercelGatewayRouting } from "@oh-my-pi/pi-catalog/types";
 import { type Api, type AssistantMessage, type CacheRetention, type Context, type ImageContent, type Message, type MessageAttribution, type Model, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ThinkingContent, type Tool, type ToolCall, type ToolResultMessage, type Usage } from "../types.js";
+export type { OpenAIPromptCacheOptions } from "../types.js";
 import { kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols.js";
 import type { AssistantMessageEventStream } from "../utils/event-stream.js";
 import type { CapturedHttpErrorResponse } from "../utils/http-inspector.js";
@@ -163,10 +164,7 @@ export declare function resolveOpenAIOutputTokenParam(input: ResolveOpenAIOutput
 export interface OpenAIGatewayRoutingParams {
     provider?: OpenRouterRouting;
     providerOptions?: {
-        gateway?: {
-            only?: string[];
-            order?: string[];
-        };
+        gateway?: Pick<VercelGatewayRouting, "only" | "order" | "caching">;
     };
 }
 export interface OpenAIGatewayRoutingCompat {
@@ -177,12 +175,28 @@ export interface OpenAIGatewayRoutingCompat {
 }
 /**
  * Apply gateway routing preferences to the request body. OpenRouter routes via
- * the top-level `provider` field; the Vercel AI Gateway routes via
- * `providerOptions.gateway`. Both Chat Completions and Responses call this; the
- * Vercel branch is inert for Responses, whose resolved compat never sets
- * `isVercelGatewayHost`.
+ * the top-level `provider` field; the Vercel AI Gateway routes Chat
+ * Completions through `providerOptions.gateway`.
+ */
+export declare function applyOpenAIGatewayRouting(params: OpenAIGatewayRoutingParams, compat: OpenAIGatewayRoutingCompat, cacheEnabled?: boolean): void;
+export interface VercelResponsesCacheParams {
+    caching?: "auto";
+    cache_anchor_items?: number;
+    cache_ttl?: "5m" | "1h";
+    providerOptions?: {
+        gateway?: Pick<VercelGatewayRouting, "only" | "order">;
+    };
+}
+export interface VercelResponsesCacheCompat {
+    isVercelGatewayHost: boolean;
+    vercelGatewayRouting?: VercelGatewayRouting;
+}
+/**
+ * Apply Vercel AI Gateway's Responses-only automatic cache controls and
+ * provider routing. Cache settings are top-level Responses fields, while
+ * `only` and `order` remain under `providerOptions.gateway`.
  */
-export declare function applyOpenAIGatewayRouting(params: OpenAIGatewayRoutingParams, compat: OpenAIGatewayRoutingCompat): void;
+export declare function applyVercelResponsesCacheControls(params: VercelResponsesCacheParams, compat: VercelResponsesCacheCompat, cacheRetention?: CacheRetention): void;
 export interface OpenAIExtraBodyOptions {
     /**
      * Fireworks rejects DeepSeek-style `thinking` toggles alongside OpenAI-style
@@ -315,6 +329,14 @@ export declare function disableChatCompletionsReasoningForDialect(params: OpenAI
  * routes clamp to `model.maxTokens` instead.
  */
 export declare function resolveOpenAICompletionsOutputClamp(model: Model<"openai-completions">, compat: ResolvedOpenAICompat): number | undefined;
+/**
+ * Provider-specific Responses API output clamp.
+ *
+ * Meta documents a 131,072-token output limit for Muse Spark 1.1, so native
+ * Meta requests may use the model's full advertised cap instead of the
+ * conservative 64k OpenAI-compatible default.
+ */
+export declare function resolveOpenAIResponsesOutputClamp(model: Pick<Model, "provider" | "maxTokens">): number | undefined;
 /**
  * Enable `tool_stream` for Z.AI/GLM-5.2 reasoning models when tools are present
  * (GLM-5.2 streams tool-call arguments incrementally and needs the flag to do so).
@@ -566,4 +588,3 @@ export declare function buildResponsesDeltaInput<TItem extends ResponseInputItem
 } | undefined, previousResponseItems: readonly TItem[] | undefined, current: {
     input?: TItem[];
 }): TItem[] | null;
-export {};

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

@@ -1,4 +1,11 @@
 import type { Api, AssistantMessage, Message, Model } from "../types.js";
+/**
+ * Toggle outbound credential-pattern redaction. When disabled (the default),
+ * {@link redactSensitiveCredentials} and {@link redactSensitiveInObject} are
+ * pass-throughs and outbound messages/system prompts leave the process
+ * unmodified.
+ */
+export declare function configureCredentialRedaction(enabled: boolean): void;
 export declare function redactSensitiveCredentials(text: string): string;
 export declare function redactSensitiveInObject(val: unknown): {
     result: unknown;

package/dist/types/registry/alibaba-token-plan.d.ts

@@ -0,0 +1,7 @@
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
+export declare function loginAlibabaTokenPlan(options: OAuthController): Promise<string>;
+export declare const alibabaTokenPlanProvider: {
+    readonly id: "alibaba-token-plan";
+    readonly name: "QwenCloud Token Plan";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+};

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

@@ -0,0 +1,7 @@
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
+export declare const loginMeta: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+export declare const metaProvider: {
+    readonly id: "meta";
+    readonly name: "Meta Model API";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+};

package/dist/types/registry/oauth/google-gemini-cli.d.ts

@@ -3,8 +3,20 @@
  * Standard Gemini models only (gemini-2.0-flash, gemini-2.5-*)
  */
 import type { OAuthController, OAuthCredentials } from "./types.js";
+interface LongRunningOperationResponse {
+    name?: string;
+    done?: boolean;
+    response?: {
+        cloudaicompanionProject?: {
+            id?: string;
+        };
+    };
+}
+export declare const POLL_MAX_ATTEMPTS = 24;
+export declare function pollOperation(operationName: string, headers: Record<string, string>, signal: AbortSignal | undefined, onProgress?: (message: string) => void): Promise<LongRunningOperationResponse>;
 export declare function loginGeminiCli(ctrl: OAuthController): Promise<OAuthCredentials>;
 /**
  * Refresh Google Cloud Code Assist token
  */
 export declare function refreshGoogleCloudToken(refreshToken: string, projectId: string): Promise<OAuthCredentials>;
+export {};

package/dist/types/registry/oauth/google-oauth-shared.d.ts

@@ -1,6 +1,40 @@
 import { OAuthCallbackFlow } from "./callback-server.js";
 import type { OAuthController, OAuthCredentials } from "./types.js";
+/**
+ * Per-request timeout for the post-callback provisioning phase (token exchange,
+ * user-info, project discovery/onboarding, LRO polling). These Cloud Code
+ * Assist calls normally settle in well under this window; a longer stall means
+ * a hung endpoint that must surface a login error instead of hanging forever.
+ * The callback server's own 300s deadline covers only the browser-callback wait
+ * ({@link OAuthCallbackFlow}) and does not gate this phase.
+ */
+export declare const OAUTH_REQUEST_TIMEOUT_MS = 30000;
+/** Options for {@link oauthFetch}. */
+export interface OAuthFetchOptions {
+    /** Provider id recorded on any {@link AIError.OAuthError} raised. */
+    provider: string;
+    /** Controller signal; when it aborts, the in-flight request is cancelled. */
+    signal?: AbortSignal;
+    /** Override the per-request timeout (defaults to {@link OAUTH_REQUEST_TIMEOUT_MS}). */
+    timeoutMs?: number;
+}
+/**
+ * Throw {@link AIError.LoginCancelledError} when the controller signal has
+ * already aborted. Gates each provisioning round-trip, which the callback-wait
+ * cancellation checks in {@link OAuthCallbackFlow} do not reach.
+ */
+export declare function throwIfLoginCancelled(signal: AbortSignal | undefined): void;
+/**
+ * `fetch` for the provisioning phase: composes the controller signal with a
+ * per-request timeout so a stalled endpoint aborts instead of hanging login,
+ * and user cancellation aborts the in-flight request. Cancellation surfaces as
+ * {@link AIError.LoginCancelledError}; a timeout surfaces as an
+ * {@link AIError.OAuthError} with `kind: "timeout"`.
+ */
+export declare function oauthFetch(url: string, init: RequestInit, { provider, signal, timeoutMs }: OAuthFetchOptions): Promise<Response>;
 export interface GoogleOAuthFlowConfig {
+    /** Provider id used in progress/error reporting and per-request fetches. */
+    provider: string;
     clientId: string;
     clientSecret: string;
     authUrl: string;
@@ -8,7 +42,7 @@ export interface GoogleOAuthFlowConfig {
     scopes: string[];
     callbackPort: number;
     callbackPath: string;
-    discoverProject: (accessToken: string, onProgress?: (message: string) => void) => Promise<string>;
+    discoverProject: (accessToken: string, onProgress?: (message: string) => void, signal?: AbortSignal) => Promise<string>;
 }
 export declare class GoogleOAuthFlow extends OAuthCallbackFlow {
     private readonly config;

package/dist/types/registry/oauth/xai-oauth.d.ts

@@ -25,7 +25,7 @@ export interface XAIOAuthIdentity {
 }
 /** Fetch optional OIDC userinfo for a valid xAI access token. */
 export declare function fetchXAIOAuthIdentity(accessToken: string, fetchOverride?: FetchImpl, signal?: AbortSignal): Promise<XAIOAuthIdentity | null>;
-/** Build the SuperGrok CLI billing URL. */
+/** Build the SuperGrok CLI billing URL. Pass `""` to omit `format` (unified monthly payload). */
 export declare function buildXAICliBillingUrl(format?: string): string;
 /**
  * Headers for SuperGrok CLI billing (`cli-chat-proxy.grok.com`).

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

@@ -0,0 +1,25 @@
+/**
+ * Z.ai / GLM OAuth flow (GLM Coding Plan · Sign in)
+ *
+ * Mirrors ZCode's desktop "Individual Plan" browser sign-in: an
+ * authorization-code flow (no PKCE) against chat.z.ai, a JSON token exchange
+ * that yields a short-lived OAuth access token, and a business-API sequence
+ * that provisions a durable `id.secret` API key. The minted key is placed in
+ * {@link OAuthCredentials.access}; `getOAuthApiKey` returns it verbatim as the
+ * request bearer for the `zai` provider, so no dialect change is needed.
+ */
+import { OAuthCallbackFlow } from "./callback-server.js";
+import type { OAuthController, OAuthCredentials } from "./types.js";
+export declare class ZaiOAuthFlow extends OAuthCallbackFlow {
+    #private;
+    constructor(ctrl: OAuthController);
+    generateAuthUrl(state: string, redirectUri: string): Promise<{
+        url: string;
+        instructions?: string;
+    }>;
+    exchangeToken(code: string, state: string, redirectUri: string): Promise<OAuthCredentials>;
+}
+/**
+ * Login with Z.ai OAuth (GLM Coding Plan).
+ */
+export declare function loginZaiOAuth(ctrl: OAuthController): Promise<OAuthCredentials>;

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

@@ -14,6 +14,10 @@ declare const ALL: ({
     readonly name: "Alibaba Coding Plan";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<import("./oauth/index.js").OAuthCredentials>;
     readonly getApiKey: (credentials: import("./oauth/index.js").OAuthCredentials) => string;
+} | {
+    readonly id: "alibaba-token-plan";
+    readonly name: "QwenCloud Token Plan";
+    readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "amazon-bedrock";
     readonly name: "Amazon Bedrock";
@@ -143,6 +147,10 @@ declare const ALL: ({
     readonly id: "lm-studio";
     readonly name: "LM Studio (Local OpenAI-compatible)";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    readonly id: "meta";
+    readonly name: "Meta Model API";
+    readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "minimax";
     readonly name: "MiniMax";
@@ -292,6 +300,13 @@ declare const ALL: ({
     readonly id: "zai";
     readonly name: "Z.AI (GLM Coding Plan)";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    readonly id: "zai-coding-plan";
+    readonly name: "Z.AI (GLM Coding Plan · Sign in)";
+    readonly storeCredentialsAs: "zai";
+    readonly callbackPort: 54548;
+    readonly pasteCodeFlow: true;
+    readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string | import("./oauth/index.js").OAuthCredentials>;
 } | {
     readonly id: "zenmux";
     readonly name: "ZenMux";

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

@@ -5,3 +5,11 @@ export declare const zaiProvider: {
     readonly name: "Z.AI (GLM Coding Plan)";
     readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
 };
+export declare const zaiCodingPlanProvider: {
+    readonly id: "zai-coding-plan";
+    readonly name: "Z.AI (GLM Coding Plan · Sign in)";
+    readonly storeCredentialsAs: "zai";
+    readonly callbackPort: 54548;
+    readonly pasteCodeFlow: true;
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string | import("./oauth/index.js").OAuthCredentials>;
+};