@oh-my-pi/pi-ai 15.9.0 → 15.9.3

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## [Unreleased]
 
+## [15.9.2] - 2026-06-05
+
+### Added
+
+- Added an AES-256-GCM auth-broker snapshot cache module and `RemoteAuthCredentialStoreOptions.onSnapshot` so broker clients can persist broker-sourced full snapshots without blocking startup on every run.
+- Added `Model.omitMaxOutputTokens` so providers (notably Ollama proxies fronting cloud catalogs) can suppress `max_output_tokens` (Responses) and `max_tokens`/`max_completion_tokens` (Completions) on the wire while still using the catalog `maxTokens` for local budgeting. Without it, `applyCommonResponsesSamplingParams` unconditionally sent the catalog cap and HTTP-400'd against upstream APIs whose true output limit was unknown to OMP. ([#1881](https://github.com/can1357/oh-my-pi/issues/1881))
+
+### Changed
+
+- Changed usage-ranked OAuth credential selection to pick deterministic session-sticky weighted buckets instead of always choosing the top-ranked account, capping the best account at 2x the baseline session likelihood while keeping equal-priority accounts evenly balanced.
+
+### Fixed
+
+- Fixed parallel `function_call` items on the OpenAI Responses API losing arguments on every call except the last when the upstream server interleaves their stream events (observed against llama.cpp and other local Responses-compat hosts). `processResponsesStream` no longer routes `function_call_arguments.{delta,done}`, `output_item.done`, content_part/text/refusal/reasoning events through a singleton `currentItem`/`currentBlock` reference; it now tracks every open item in registries keyed by `output_index` and `item_id` so each event is folded into the matching block and the emitted `toolcall_end` carries the correct `contentIndex`. ([#1880](https://github.com/can1357/oh-my-pi/issues/1880))
+
+## [15.9.1] - 2026-06-04
+
+### Added
+
+- Added regional Xiaomi Token Plan login/provider entries (`xiaomi-token-plan-sgp`, `xiaomi-token-plan-ams`, `xiaomi-token-plan-cn`) so `omp login` can store token-plan keys against the selected region. ([#1846](https://github.com/can1357/oh-my-pi/issues/1846))
+
+### Fixed
+
+- Removed the `context-1m-2025-08-07` (1M long-context) beta from the Anthropic agent request headers, the OAuth model-discovery header, and the Claude usage-API header. Sending it caused subscription/OAuth requests without long-context credits to fail with `429 Usage credits are required for long context requests`, breaking Sonnet. The remaining betas are unchanged.
+- Fixed Kimi K2.x `maxTokens` on Fireworks and Fire Pass (`fireworks/kimi-k2.5`, `fireworks/kimi-k2.6`, `firepass/kimi-k2.6-turbo`) being inherited from Fireworks `/v1/models` discovery (`max_completion_tokens: 65536`) rather than the published Kimi-on-Fireworks output budget, which let callers (and the openai-completions default-injection safety net) ship a budget the router cannot honor and made runaway reasoning traces more likely. The Fireworks resolver now clamps every Kimi K2.x id (public catalog ids and the canonical `accounts/fireworks/{models,routers}/kimi-k2…` wire form) to 32,768 output tokens, and the generator applies the same cap as a post-processing safety net so the `firepass` static fallback and the bundled `fireworks` entries stay in sync across regens. ([#1849](https://github.com/can1357/oh-my-pi/issues/1849))
+- Fixed Xiaomi Token Plan MiMo OpenAI-compatible tool-call continuations omitting required `reasoning_content` replay. ([#1846](https://github.com/can1357/oh-my-pi/issues/1846))
+- Fixed Anthropic prompt caching for OpenAI-compatible Claude proxies by honoring `compat.cacheControlFormat: "anthropic"` outside OpenRouter. ([#1845](https://github.com/can1357/oh-my-pi/issues/1845))
+- Fixed Moonshot Kimi K2.6 silently pausing for many seconds between tool calls because the server discarded the `reasoning_content` that omp was already sending with every assistant tool-call replay. The K2.6 `thinking` parameter takes an extra `keep` field whose default (`null`) ignores historical reasoning, so K2.6 had to re-derive its full chain-of-thought from the user prompt on every iteration of the agent loop. The Moonshot direct (`api.moonshot.ai`) and Kimi Code (`api.kimi.com`) wire bodies now send `thinking: { type: "enabled", keep: "all" }` for `kimi-k2.6` requests with reasoning enabled, matching Moonshot's documented best practice for multi-step tool-calling agents. The flag is gated on the K2.6 id and the two native hosts because earlier Moonshot models (K2.5 and below) 400 on the unknown field and every Kimi gateway (OpenRouter, OpenCode, Kilo, Fireworks, …) speaks its own thinking shape. ([#1838](https://github.com/can1357/oh-my-pi/issues/1838))
+- Fixed Alibaba DashScope (Bailian) compatible-mode endpoint `400 InternalError.Algo.InvalidParameter: The provided messages input is invalid. The error info is [Unexpected item type in content.]` when a screenshot or other image-producing tool result was folded into a known text-only Qwen turn (e.g. `qwen3.7-max`, `qwen-max`, `qwen3-coder-*`) hosted at `dashscope.aliyuncs.com/compatible-mode/v1`. `convertMessages` in `openai-completions` no longer forwards `image_url` content parts for those text-only id families even when a misconfigured custom provider claims `input: ["text", "image"]`; multimodal compatible-mode ids such as `qwen3.7-plus` and `qwen-vl-max` still rely on the catalog `input` field. The tool-result branch and the user-content branch both fall back to the standard `[image omitted: model does not support vision]` placeholder for text-only ids so the model still sees the attachment intent. ([#1859](https://github.com/can1357/oh-my-pi/issues/1859))
+
 ## [15.9.0] - 2026-06-04
 
 ### Fixed
@@ -18,6 +48,7 @@
 - Fixed MiniMax Coding Plan China login opening the international `platform.minimax.io` subscription page instead of the China `platform.minimaxi.com` page.
 
 ## [15.8.0] - 2026-06-02
+
 ### Added
 
 - Added `AnthropicMessagesClient` and related Anthropic wire types/errors via `anthropic-client` export so callers can build a standalone Anthropic Messages client without depending on `@anthropic-ai/sdk`

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

@@ -2,4 +2,5 @@ export * from "./client";
 export * from "./refresher";
 export * from "./remote-store";
 export * from "./server";
+export * from "./snapshot-cache";
 export * from "./types";

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

@@ -16,6 +16,11 @@ export interface RemoteAuthCredentialStoreOptions {
      * to long-poll permanently when the broker returns 404. Default `true`.
      */
     streamSnapshots?: boolean;
+    /**
+     * Called after broker-sourced full snapshots are applied. The constructor's
+     * initial snapshot intentionally does not trigger this hook.
+     */
+    onSnapshot?: (snapshot: SnapshotResponse, generation: number) => void;
 }
 export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     #private;

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

@@ -0,0 +1,17 @@
+import type { SnapshotResponse } from "./types";
+export interface ReadAuthBrokerSnapshotCacheOptions {
+    path: string;
+    token: string;
+    url: string;
+    ttlMs: number;
+    /** Override clock for deterministic tests. */
+    now?: () => number;
+}
+export interface WriteAuthBrokerSnapshotCacheOptions {
+    path: string;
+    token: string;
+    url: string;
+    snapshot: SnapshotResponse;
+}
+export declare function readAuthBrokerSnapshotCache(opts: ReadAuthBrokerSnapshotCacheOptions): Promise<SnapshotResponse | null>;
+export declare function writeAuthBrokerSnapshotCache(opts: WriteAuthBrokerSnapshotCacheOptions): Promise<void>;

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

@@ -96,6 +96,8 @@ export declare const DEFAULT_AUTH_BROKER_BIND = "127.0.0.1:8765";
 export declare const DEFAULT_REFRESH_SKEW_MS: number;
 /** Default broker refresh-loop cadence. */
 export declare const DEFAULT_REFRESH_INTERVAL_MS = 60000;
+/** Default freshness window for the encrypted local broker snapshot cache. */
+export declare const DEFAULT_SNAPSHOT_CACHE_TTL_MS: number;
 /** Keepalive cadence for `GET /v1/snapshot/stream` SSE comments. */
 export declare const DEFAULT_STREAM_KEEPALIVE_MS = 20000;
 /**

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

@@ -377,11 +377,25 @@ type AuthApiKeyOptions = {
  */
 export interface OAuthAccess {
     accessToken: string;
+    credentialId?: number;
     accountId?: string;
     email?: string;
     projectId?: string;
     enterpriseUrl?: string;
 }
+export interface OAuthAccessFailure {
+    credentialId?: number;
+    accountId?: string;
+    email?: string;
+    projectId?: string;
+    enterpriseUrl?: string;
+    error: string;
+}
+export type OAuthAccessResolution = ({
+    ok: true;
+} & OAuthAccess) | ({
+    ok: false;
+} & OAuthAccessFailure);
 export interface InvalidateCredentialMatchingOptions {
     signal?: AbortSignal;
     sessionId?: string;
@@ -622,6 +636,15 @@ export declare class AuthStorage {
      * OAuth with an explicit API key.
      */
     getOAuthAccess(provider: string, sessionId?: string, options?: AuthApiKeyOptions): Promise<OAuthAccess | undefined>;
+    /**
+     * Resolve every stored OAuth credential for `provider` independently.
+     *
+     * Refreshes credentials through the same broker/local path as
+     * {@link AuthStorage.getOAuthAccess}, but does not rank, round-robin, or
+     * stop after the first usable account. Intended for diagnostics that must
+     * exercise each stored account exactly once.
+     */
+    getOAuthAccesses(provider: string, options?: AuthApiKeyOptions): Promise<OAuthAccessResolution[]>;
     invalidateCredentialMatching(provider: string, apiKey: string, options?: InvalidateCredentialMatchingOptions): Promise<boolean>;
     invalidateCredentialMatching(provider: string, apiKey: string, signal?: AbortSignal): Promise<boolean>;
     /**

package/dist/types/provider-models/openai-compat.d.ts

@@ -1,5 +1,5 @@
 import type { ModelManagerOptions } from "../model-manager";
-import type { Api, Model } from "../types";
+import type { Api, Model, Provider } from "../types";
 export interface ModelsDevModel {
     id?: string;
     name?: string;
@@ -110,6 +110,27 @@ export interface ZhipuCodingPlanModelManagerConfig {
     baseUrl?: string;
 }
 export declare function zhipuCodingPlanModelManagerOptions(config?: ZhipuCodingPlanModelManagerConfig): ModelManagerOptions<"openai-completions">;
+/**
+ * Fireworks-published cap for the Kimi K2 family. Fireworks' `/v1/models`
+ * envelope generically reports `max_completion_tokens: 65536` for every Kimi
+ * deployment, but Kimi K2 (instruct / thinking / turbo) on Fireworks is
+ * documented to ship long reasoning traces that should be bounded — capping
+ * at 32,768 prevents handing callers a budget the router cannot honor.
+ * See https://github.com/can1357/oh-my-pi/issues/1849.
+ */
+export declare const FIREWORKS_KIMI_MAX_TOKENS = 32768;
+/**
+ * Returns true for any Kimi K2.x public model id served by Fireworks-backed
+ * providers (`fireworks` direct, `firepass` router). Matches both the public
+ * catalog id (`kimi-k2.5`, `kimi-k2.6`, `kimi-k2.6-turbo`) and the canonical
+ * Fireworks wire id (`accounts/fireworks/{models,routers}/kimi-k2…`).
+ */
+export declare function isFireworksKimiK2ModelId(modelId: string): boolean;
+/**
+ * Clamp the Kimi K2 family's `maxTokens` to {@link FIREWORKS_KIMI_MAX_TOKENS}
+ * on Fireworks-backed providers, leaving every other model untouched.
+ */
+export declare function clampFireworksKimiMaxTokens(modelId: string, candidate: number): number;
 export interface FireworksModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
@@ -219,10 +240,16 @@ export interface CloudflareAiGatewayModelManagerConfig {
     baseUrl?: string;
 }
 export declare function cloudflareAiGatewayModelManagerOptions(config?: CloudflareAiGatewayModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
+/** Region codes for Xiaomi Token Plan clusters exposed as separate login providers. */
+export type XiaomiTokenPlanRegion = "sgp" | "ams" | "cn";
+/** Configures Xiaomi standard or regional Token Plan OpenAI-compatible model discovery. */
 export interface XiaomiModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    providerId?: Provider;
+    tokenPlanRegion?: XiaomiTokenPlanRegion;
 }
+/** Builds a Xiaomi model manager, preserving Token Plan region provider ids during discovery. */
 export declare function xiaomiModelManagerOptions(config?: XiaomiModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface LiteLLMModelManagerConfig {
     apiKey?: string;

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

@@ -1,9 +1,11 @@
 import type { Model, OpenAICompat } from "../types";
 type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
-export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode">> & {
+export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "cacheControlFormat" | "thinkingKeep">> & {
     openRouterRouting?: OpenAICompat["openRouterRouting"];
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
     extraBody?: OpenAICompat["extraBody"];
+    cacheControlFormat?: OpenAICompat["cacheControlFormat"];
+    thinkingKeep?: OpenAICompat["thinkingKeep"];
     toolStrictMode: ResolvedToolStrictMode;
 };
 /**

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

@@ -64,8 +64,13 @@ type CommonSamplingOptions = Pick<StreamOptions, "temperature" | "topP" | "topK"
 /**
  * Apply the common `StreamOptions` → Responses sampling-parameter mapping (max output tokens,
  * temperature, top-p/k, min-p, presence/repetition penalties, service tier). Mutates `params`.
+ *
+ * `max_output_tokens` is suppressed when {@link Model.omitMaxOutputTokens} is `true`, so
+ * proxies (notably Ollama) that forward to upstream APIs with an unknown output-token cap
+ * can let the upstream apply its own default instead of 400-ing on `maxTokens` values that
+ * reflect the model's context window rather than the upstream output limit.
  */
-export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, provider: string): void;
+export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, model: Pick<Model, "provider" | "omitMaxOutputTokens">): void;
 type ReasoningOptions = {
     reasoning?: string;
     reasoningSummary?: "auto" | "detailed" | "concise" | null;

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

@@ -1,4 +1,4 @@
-import type { ImageContent, TextContent } from "../types";
+import type { ImageContent, Model, TextContent } from "../types";
 export declare const NON_VISION_IMAGE_PLACEHOLDER = "[image omitted: model does not support vision]";
 export declare function partitionVisionContent(content: ReadonlyArray<TextContent | ImageContent>, supportsImages: boolean): {
     textBlocks: TextContent[];
@@ -6,3 +6,15 @@ export declare function partitionVisionContent(content: ReadonlyArray<TextConten
     omittedImages: boolean;
 };
 export declare function joinTextWithImagePlaceholder(text: string, omittedImages: boolean): string;
+/**
+ * Detect known text-only Qwen models served via Alibaba DashScope's consumer
+ * `compatible-mode` endpoint that the upstream chat-completions API rejects
+ * multimodal content arrays for. The compatible-mode endpoint also serves
+ * multimodal Qwen SKUs without `vl` in the id (e.g. `qwen3.7-plus`), so this
+ * guard only covers families verified to be text-only for issue #1859:
+ * `qwen*-max` and `qwen*-coder*`.
+ *
+ * Used as a defensive override in `convertMessages` so a misconfigured custom
+ * provider (issue #1859) can't drive the request into an unrecoverable 400.
+ */
+export declare function isDashscopeCompatibleModeTextOnlyQwen(model: Model<"openai-completions">): boolean;

package/dist/types/types.d.ts

@@ -48,7 +48,7 @@ export interface ThinkingConfig {
     /** Provider-specific transport used to encode the selected effort. */
     mode: ThinkingControlMode;
 }
-export type KnownProvider = "alibaba-coding-plan" | "amazon-bedrock" | "anthropic" | "google" | "google-gemini-cli" | "google-antigravity" | "google-vertex" | "openai" | "openai-codex" | "kimi-code" | "minimax-code" | "minimax-code-cn" | "github-copilot" | "fireworks" | "firepass" | "gitlab-duo" | "cursor" | "deepseek" | "xai" | "xai-oauth" | "groq" | "cerebras" | "openrouter" | "kilo" | "vercel-ai-gateway" | "zai" | "zhipu-coding-plan" | "mistral" | "minimax" | "opencode-go" | "opencode-zen" | "synthetic" | "cloudflare-ai-gateway" | "huggingface" | "litellm" | "moonshot" | "nvidia" | "nanogpt" | "ollama" | "ollama-cloud" | "qianfan" | "qwen-portal" | "together" | "venice" | "vllm" | "xiaomi" | "wafer-pass" | "wafer-serverless" | "zenmux" | "lm-studio";
+export type KnownProvider = "alibaba-coding-plan" | "amazon-bedrock" | "anthropic" | "google" | "google-gemini-cli" | "google-antigravity" | "google-vertex" | "openai" | "openai-codex" | "kimi-code" | "minimax-code" | "minimax-code-cn" | "github-copilot" | "fireworks" | "firepass" | "gitlab-duo" | "cursor" | "deepseek" | "xai" | "xai-oauth" | "groq" | "cerebras" | "openrouter" | "kilo" | "vercel-ai-gateway" | "zai" | "zhipu-coding-plan" | "mistral" | "minimax" | "opencode-go" | "opencode-zen" | "synthetic" | "cloudflare-ai-gateway" | "huggingface" | "litellm" | "moonshot" | "nvidia" | "nanogpt" | "ollama" | "ollama-cloud" | "qianfan" | "qwen-portal" | "together" | "venice" | "vllm" | "xiaomi" | "xiaomi-token-plan-sgp" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "wafer-pass" | "wafer-serverless" | "zenmux" | "lm-studio";
 export type Provider = KnownProvider | string;
 import type { Effort } from "./model-thinking";
 /** Token budgets for each thinking level (token-based providers only) */
@@ -421,6 +421,8 @@ export interface UserMessage {
     content: string | (TextContent | ImageContent)[];
     /** True if the message was injected by the system (e.g., auto-continue). */
     synthetic?: boolean;
+    /** True when injected mid-turn as a steer; consumed by the agent's pre-LLM transform to wrap it for emphasis. Never rendered. */
+    steering?: boolean;
     /** Who initiated this message for billing/attribution semantics. */
     attribution?: MessageAttribution;
     /** Provider-specific opaque payload used to reconstruct transport-native history. */
@@ -650,6 +652,8 @@ export interface OpenAICompat {
     requiresMistralToolIds?: boolean;
     /** Format for reasoning/thinking parameter. "openai" uses reasoning_effort, "openrouter" uses reasoning: { effort }, "zai" uses thinking: { type: "enabled" | "disabled" } (also used by Moonshot Kimi), "qwen" uses top-level enable_thinking, and "qwen-chat-template" uses chat_template_kwargs.enable_thinking. Default: "openai". */
     thinkingFormat?: "openai" | "openrouter" | "zai" | "qwen" | "qwen-chat-template";
+    /** Optional `thinking.keep` value for Z.ai/Moonshot-style thinking params. Set false to suppress auto-detected keep. Default: auto-detected. */
+    thinkingKeep?: "all" | false;
     /** Which reasoning content field to emit on assistant messages. Default: auto-detected. */
     reasoningContentField?: "reasoning_content" | "reasoning" | "reasoning_text";
     /** Whether assistant tool-call messages must include reasoning content. Default: false. */
@@ -681,6 +685,8 @@ export interface OpenAICompat {
     vercelGatewayRouting?: VercelGatewayRouting;
     /** Extra fields to include in request body (e.g. gateway routing hints for OpenClaw-style proxies). */
     extraBody?: Record<string, unknown>;
+    /** Whether chat-completions payloads should include provider-specific prompt-cache markers. */
+    cacheControlFormat?: "anthropic" | undefined;
     /** Whether the provider supports the `strict` field in tool definitions. Default: auto-detected per provider/baseUrl (conservative for unknown providers). */
     supportsStrictMode?: boolean;
     /** Whether tool schemas must be sent either all strict or all non-strict. Undefined keeps the existing per-tool mixed behavior. */
@@ -757,6 +763,18 @@ export interface Model<TApi extends Api = any> {
     premiumMultiplier?: number;
     contextWindow: number;
     maxTokens: number;
+    /**
+     * When `true`, providers MUST omit `max_output_tokens` (Responses) /
+     * `max_tokens` / `max_completion_tokens` (Completions) from the outbound
+     * request and let the upstream API decide the per-response cap. `maxTokens`
+     * is still used locally for budgeting (compaction, context promotion); only
+     * the wire field is suppressed.
+     *
+     * Use this for proxies (notably Ollama) that forward to a backend whose true
+     * output limit OMP cannot discover — sending the wrong value triggers 400s
+     * from the upstream provider.
+     */
+    omitMaxOutputTokens?: boolean;
     headers?: Record<string, string>;
     /**
      * Streaming transport override. When `"pi-native"`, `streamSimple` routes

package/dist/types/utils/oauth/types.d.ts

@@ -7,7 +7,7 @@ export type OAuthCredentials = {
     email?: string;
     accountId?: string;
 };
-export type OAuthProvider = "alibaba-coding-plan" | "anthropic" | "cerebras" | "cloudflare-ai-gateway" | "cursor" | "deepseek" | "fireworks" | "firepass" | "github-copilot" | "google-gemini-cli" | "google-antigravity" | "gitlab-duo" | "huggingface" | "kimi-code" | "kilo" | "kagi" | "litellm" | "lm-studio" | "minimax-code" | "minimax-code-cn" | "moonshot" | "nvidia" | "nanogpt" | "ollama" | "ollama-cloud" | "openai-codex" | "openai-codex-device" | "opencode-go" | "openrouter" | "opencode-zen" | "parallel" | "perplexity" | "qianfan" | "qwen-portal" | "synthetic" | "tavily" | "together" | "venice" | "vercel-ai-gateway" | "wafer-pass" | "wafer-serverless" | "vllm" | "xai-oauth" | "xiaomi" | "zenmux" | "zai" | "zhipu-coding-plan";
+export type OAuthProvider = "alibaba-coding-plan" | "anthropic" | "cerebras" | "cloudflare-ai-gateway" | "cursor" | "deepseek" | "fireworks" | "firepass" | "github-copilot" | "google-gemini-cli" | "google-antigravity" | "gitlab-duo" | "huggingface" | "kimi-code" | "kilo" | "kagi" | "litellm" | "lm-studio" | "minimax-code" | "minimax-code-cn" | "moonshot" | "nvidia" | "nanogpt" | "ollama" | "ollama-cloud" | "openai-codex" | "openai-codex-device" | "opencode-go" | "openrouter" | "opencode-zen" | "parallel" | "perplexity" | "qianfan" | "qwen-portal" | "synthetic" | "tavily" | "together" | "venice" | "vercel-ai-gateway" | "wafer-pass" | "wafer-serverless" | "vllm" | "xai-oauth" | "xiaomi" | "xiaomi-token-plan-sgp" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "zenmux" | "zai" | "zhipu-coding-plan";
 export type OAuthProviderId = OAuthProvider | (string & {});
 export type OAuthPrompt = {
     message: string;

package/dist/types/utils/oauth/xiaomi.d.ts

@@ -4,12 +4,12 @@
  * Xiaomi MiMo provides OpenAI-compatible models via
  * https://api.xiaomimimo.com/v1.
  *
- * This is not OAuth - it's a simple API key flow:
- * 1. Open browser to Xiaomi MiMo API key console
- * 2. User copies their API key
- * 3. User pastes the API key into the CLI
+ * Standard Xiaomi login opens the pay-as-you-go API key console. Token Plan
+ * login opens plan management so users copy the regional `tp-...` key.
  */
 import type { OAuthController } from "./types";
+/** Region codes accepted by the Xiaomi Token Plan login flow. */
+export type XiaomiTokenPlanRegion = "sgp" | "ams" | "cn";
 /**
  * Login to Xiaomi MiMo.
  *
@@ -17,3 +17,9 @@ import type { OAuthController } from "./types";
  * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
  */
 export declare function loginXiaomi(options: OAuthController): Promise<string>;
+/**
+ * Login to a regional Xiaomi Token Plan endpoint.
+ *
+ * Prompts for a token-plan API key and validates it against the selected region.
+ */
+export declare function loginXiaomiTokenPlan(options: OAuthController, region: XiaomiTokenPlanRegion): Promise<string>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "15.9.0",
+	"version": "15.9.3",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -39,7 +39,7 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-utils": "15.9.0",
+		"@oh-my-pi/pi-utils": "15.9.3",
 		"openai": "^6.39.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/auth-broker/index.ts

@@ -2,4 +2,5 @@ export * from "./client";
 export * from "./refresher";
 export * from "./remote-store";
 export * from "./server";
+export * from "./snapshot-cache";
 export * from "./types";

package/src/auth-broker/remote-store.ts

@@ -73,11 +73,17 @@ export interface RemoteAuthCredentialStoreOptions {
 	 * to long-poll permanently when the broker returns 404. Default `true`.
 	 */
 	streamSnapshots?: boolean;
+	/**
+	 * Called after broker-sourced full snapshots are applied. The constructor's
+	 * initial snapshot intentionally does not trigger this hook.
+	 */
+	onSnapshot?: (snapshot: SnapshotResponse, generation: number) => void;
 }
 
 export class RemoteAuthCredentialStore implements AuthCredentialStore {
 	readonly #client: AuthBrokerClient;
 	readonly #streamSnapshots: boolean;
+	readonly #onSnapshot?: (snapshot: SnapshotResponse, generation: number) => void;
 	#snapshot: SnapshotResponse = emptySnapshot();
 	#snapshotReceivedAt = Date.now();
 	#generation = 0;
@@ -100,6 +106,7 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 		this.#client = opts.client;
 		this.#streamSnapshots = opts.streamSnapshots ?? true;
 		this.#applySnapshot(opts.initialSnapshot ?? emptySnapshot(), opts.initialSnapshot?.generation ?? 0);
+		this.#onSnapshot = opts.onSnapshot;
 		void this.#runBackground();
 	}
 
@@ -115,6 +122,13 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 		this.#snapshot = snapshot;
 		this.#generation = generation;
 		this.#snapshotReceivedAt = Date.now();
+		const onSnapshot = this.#onSnapshot;
+		if (!onSnapshot) return;
+		try {
+			onSnapshot(snapshot, generation);
+		} catch (error) {
+			logger.debug("auth-broker snapshot callback failed", { error: String(error) });
+		}
 	}
 
 	async #runBackground(): Promise<void> {

package/src/auth-broker/snapshot-cache.ts

@@ -0,0 +1,174 @@
+/**
+ * AES-GCM encrypted local cache for auth-broker snapshots.
+ *
+ * The cache is defense-in-depth for at-rest snapshots: a copied cache file is
+ * useless without the matching broker bearer token and URL. The token itself is
+ * still the trust boundary; a process that can read both the token and this file
+ * can decrypt the snapshot.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+import type { SnapshotResponse } from "./types";
+import { snapshotResponseSchema } from "./wire-schemas";
+
+const MAGIC = new Uint8Array([0x4f, 0x4d, 0x50, 0x53]); // "OMPS"
+const VERSION = 1;
+const VERSION_OFFSET = MAGIC.byteLength;
+const IV_OFFSET = VERSION_OFFSET + 1;
+const IV_LENGTH = 12;
+const HEADER_LENGTH = IV_OFFSET + IV_LENGTH;
+const AES_ALGORITHM = "AES-GCM";
+const TEXT_ENCODER = new TextEncoder();
+const TEXT_DECODER = new TextDecoder();
+const HEX = "0123456789abcdef";
+
+export interface ReadAuthBrokerSnapshotCacheOptions {
+	path: string;
+	token: string;
+	url: string;
+	ttlMs: number;
+	/** Override clock for deterministic tests. */
+	now?: () => number;
+}
+
+export interface WriteAuthBrokerSnapshotCacheOptions {
+	path: string;
+	token: string;
+	url: string;
+	snapshot: SnapshotResponse;
+}
+
+export async function readAuthBrokerSnapshotCache(
+	opts: ReadAuthBrokerSnapshotCacheOptions,
+): Promise<SnapshotResponse | null> {
+	if (opts.ttlMs <= 0) return null;
+	let data: Uint8Array;
+	try {
+		data = await fs.readFile(opts.path);
+	} catch (error) {
+		if (isEnoent(error)) return null;
+		throw error;
+	}
+
+	try {
+		const plaintext = await decryptCachePayload(data, opts.token, opts.url);
+		if (!plaintext) return null;
+		const parsed: unknown = JSON.parse(TEXT_DECODER.decode(plaintext));
+		const result = snapshotResponseSchema.safeParse(parsed);
+		if (!result.success) {
+			logger.debug("auth-broker snapshot cache schema invalid", { path: opts.path });
+			return null;
+		}
+		const snapshot = result.data;
+		const now = opts.now?.() ?? Date.now();
+		if (now - snapshot.generatedAt > opts.ttlMs) return null;
+		return snapshot;
+	} catch (error) {
+		logger.debug("auth-broker snapshot cache read failed", { path: opts.path, error: String(error) });
+		return null;
+	}
+}
+
+export async function writeAuthBrokerSnapshotCache(opts: WriteAuthBrokerSnapshotCacheOptions): Promise<void> {
+	const payload = await encryptCachePayload(opts.snapshot, opts.token, opts.url);
+	await fs.mkdir(path.dirname(opts.path), { recursive: true });
+	const tmpPath = `${opts.path}.${process.pid}.${randomHex(8)}.tmp`;
+	let removeTemp = false;
+	try {
+		const handle = await fs.open(tmpPath, "wx", 0o600);
+		removeTemp = true;
+		try {
+			await handle.writeFile(payload);
+		} finally {
+			await handle.close();
+		}
+		await fs.chmod(tmpPath, 0o600);
+		await fs.rename(tmpPath, opts.path);
+		removeTemp = false;
+	} finally {
+		if (removeTemp) await fs.rm(tmpPath, { force: true }).catch(() => {});
+	}
+}
+
+async function encryptCachePayload(snapshot: SnapshotResponse, token: string, url: string): Promise<Uint8Array> {
+	const key = await deriveAesKey(token, ["encrypt"]);
+	const iv = new Uint8Array(IV_LENGTH);
+	globalThis.crypto.getRandomValues(iv);
+	const plaintext = TEXT_ENCODER.encode(JSON.stringify(snapshot));
+	const ciphertext = new Uint8Array(
+		await globalThis.crypto.subtle.encrypt(
+			{
+				name: AES_ALGORITHM,
+				iv,
+				additionalData: TEXT_ENCODER.encode(url),
+			},
+			key,
+			plaintext,
+		),
+	);
+	const payload = new Uint8Array(HEADER_LENGTH + ciphertext.byteLength);
+	payload.set(MAGIC, 0);
+	payload[VERSION_OFFSET] = VERSION;
+	payload.set(iv, IV_OFFSET);
+	payload.set(ciphertext, HEADER_LENGTH);
+	return payload;
+}
+
+async function decryptCachePayload(data: Uint8Array, token: string, url: string): Promise<Uint8Array | null> {
+	if (data.byteLength <= HEADER_LENGTH) {
+		logger.debug("auth-broker snapshot cache file too short");
+		return null;
+	}
+	for (let i = 0; i < MAGIC.byteLength; i++) {
+		if (data[i] !== MAGIC[i]) {
+			logger.debug("auth-broker snapshot cache magic mismatch");
+			return null;
+		}
+	}
+	if (data[VERSION_OFFSET] !== VERSION) {
+		logger.debug("auth-broker snapshot cache version mismatch", { version: data[VERSION_OFFSET] });
+		return null;
+	}
+	const key = await deriveAesKey(token, ["decrypt"]);
+	const iv = asStrict(data.subarray(IV_OFFSET, HEADER_LENGTH));
+	const ciphertext = asStrict(data.subarray(HEADER_LENGTH));
+	try {
+		return new Uint8Array(
+			await globalThis.crypto.subtle.decrypt(
+				{
+					name: AES_ALGORITHM,
+					iv,
+					additionalData: TEXT_ENCODER.encode(url),
+				},
+				key,
+				ciphertext,
+			),
+		);
+	} catch (error) {
+		logger.debug("auth-broker snapshot cache decrypt failed", { error: String(error) });
+		return null;
+	}
+}
+
+async function deriveAesKey(token: string, usages: Array<"encrypt" | "decrypt">): Promise<CryptoKey> {
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", TEXT_ENCODER.encode(token));
+	return globalThis.crypto.subtle.importKey("raw", digest, AES_ALGORITHM, false, usages);
+}
+
+function asStrict(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
+	if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+		return bytes as Uint8Array<ArrayBuffer>;
+	}
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy;
+}
+
+function randomHex(byteLength: number): string {
+	const bytes = new Uint8Array(byteLength);
+	globalThis.crypto.getRandomValues(bytes);
+	let out = "";
+	for (const byte of bytes) out += HEX[byte >> 4] + HEX[byte & 15];
+	return out;
+}

package/src/auth-broker/types.ts

@@ -117,6 +117,9 @@ export const DEFAULT_REFRESH_SKEW_MS = 5 * 60_000;
 /** Default broker refresh-loop cadence. */
 export const DEFAULT_REFRESH_INTERVAL_MS = 60_000;
 
+/** Default freshness window for the encrypted local broker snapshot cache. */
+export const DEFAULT_SNAPSHOT_CACHE_TTL_MS = 60 * 60_000;
+
 /** Keepalive cadence for `GET /v1/snapshot/stream` SSE comments. */
 export const DEFAULT_STREAM_KEEPALIVE_MS = 20_000;