@linxiraos/pi-ai 1.1.4 → 1.1.5

package/CHANGELOG.md

@@ -2,11 +2,9 @@
 
 ## [Unreleased]
 
-## [1.1.4] - 2026-08-26
+## [1.1.5] - 2026-08-26
 
-### Changed
-
-- 同步 1.1.4 发布线（与 1.1.3 无功能差异）。
+- 同步上游 OMP v18.0.5 / v18.0.6：新增 Yolo-Auto / OpenRouter 浏览器登录与 DeepInfra 支持，空补全重试重构（withReplaySafeStreamRetry）。
 
 ## [1.1.3] - 2026-08-25
 

package/README.md

@@ -60,6 +60,7 @@ Unified LLM API with automatic model discovery, provider configuration, token an
 - **NVIDIA** (requires `NVIDIA_API_KEY`)
 - **NanoGPT** (requires `NANO_GPT_API_KEY`)
 - **Novita** (requires `NOVITA_API_KEY`)
+- **DeepInfra** (requires `DEEPINFRA_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
 | NVIDIA         | `NVIDIA_API_KEY`                                                             |
 | NanoGPT        | `NANO_GPT_API_KEY`                                                          |
 | Novita         | `NOVITA_API_KEY`                                                           |
+| DeepInfra      | `DEEPINFRA_API_KEY`                                                          |
 | Venice         | `VENICE_API_KEY`                                                             |
 | Moonshot       | `MOONSHOT_API_KEY`                                                           |
 | xAI            | `XAI_API_KEY`                                                                |
@@ -983,6 +985,7 @@ Provider endpoint defaults for the current OpenAI-compatible integrations:
 - NVIDIA: `https://integrate.api.nvidia.com/v1`
 - NanoGPT: `https://nano-gpt.com/api/v1`
 - Novita: `https://api.novita.ai/openai/v1`
+- DeepInfra: `https://api.deepinfra.com/v1/openai`
 - Hugging Face Inference: `https://router.huggingface.co/v1`
 - Venice: `https://api.venice.ai/api/v1`
 - Xiaomi MiMo: `https://api.xiaomimimo.com/anthropic`
@@ -1084,7 +1087,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, 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.
+For the current API-key onboarding flows, the library covers Together, Moonshot, Qianfan, NVIDIA, NanoGPT, Novita, DeepInfra, 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
 

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

@@ -35,6 +35,14 @@ export interface RemoteAuthCredentialStoreOptions {
     accountPool?: AuthBrokerAccountPool;
     /** Flush cadence for batched observed-usage reports. Default 10s. */
     observedUsageFlushMs?: number;
+    /**
+     * Idle window after the last foreground store use before background
+     * snapshot sync (SSE stream / long-poll) disconnects and parks. A parked
+     * store holds no timers or sockets, so an unclosed store never keeps the
+     * process alive longer than one idle window. Sync resumes transparently on
+     * the next use. Default 20s.
+     */
+    backgroundIdleMs?: number;
 }
 export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     #private;

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

@@ -218,11 +218,8 @@ export declare function isInvalidThinkingSignatureError(message: string): boolea
  */
 export declare function maybeAddReplayUnsignedThinkingHint(model: Model<"anthropic-messages">, message: string): string;
 /**
- * Public entry: wrap the single-attempt streamer with bounded empty-completion
- * retries (a benign terminal stop carrying no content/usage would otherwise
- * stall the agent loop). The inner attempt keeps its own provider-failure retry
- * loop; this layer only re-issues a fresh request on an empty success. Shared
- * with the OpenAI-completions provider via `withEmptyCompletionRetry`.
+ * Public entry: retry benign empty completions before they reach the agent
+ * loop. The inner attempt owns Anthropic provider-failure retries.
  */
 export declare const streamAnthropic: StreamFunction<"anthropic-messages">;
 export type AnthropicSystemBlock = {

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

@@ -12,6 +12,9 @@ export interface AzureOpenAIResponsesOptions extends StreamOptions {
     disableReasoning?: boolean;
 }
 /**
- * Generate function for Azure OpenAI Responses API
+ * Retries transient Azure stream failures only before assistant output commits
+ * the attempt. The unsupported explicit prompt-cache config is rejected
+ * synchronously here — callers of the direct entrypoint get the immediate
+ * `ConfigurationError` rather than a stream whose `.result()` rejects later.
  */
 export declare const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses">;

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

@@ -38,10 +38,8 @@ export interface OpenAICompletionsOptions extends StreamOptions {
     promptCache?: OpenAIPromptCacheOptions;
 }
 /**
- * Public entry: wrap the single-attempt streamer with bounded empty-completion
- * retries — flaky gateways occasionally 200 with `delta: {}` + `finish_reason:
- * "stop"` and no usage, which would otherwise stall the agent loop. Shared with
- * the Anthropic provider via `withEmptyCompletionRetry`.
+ * Retries benign empty completions and transient provider failures only before
+ * assistant output commits the attempt.
  */
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
 export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined): AssistantMessage["usage"];

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

@@ -106,10 +106,9 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
     cache_ttl?: "5m" | "1h";
 };
 /**
- * Public entry: wrap the single-attempt Responses streamer with bounded
- * empty-completion retries — a `response.completed` carrying no content/usage
- * would otherwise stall the agent loop. Shared with the OpenAI-completions and
- * Anthropic providers via `withEmptyCompletionRetry`.
+ * Public entry: retry benign empty completions before they reach the agent
+ * loop. Transient stream failures are retried inside the attempt so stateful
+ * Responses request metadata remains stable.
  */
 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, statefulCacheBaseline?: ResponseInput): {

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

@@ -234,6 +234,7 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
     preserve_thinking?: boolean;
     chat_template_kwargs?: {
         enable_thinking?: boolean;
+        thinking?: boolean;
         preserve_thinking?: boolean;
         reasoning_effort?: string;
     };
@@ -684,4 +685,4 @@ export declare function buildResponsesDeltaInput<TItem extends ResponseInputItem
     input?: TItem[];
 } | undefined, previousResponseItems: readonly TItem[] | undefined, current: {
     input?: TItem[];
-}): TItem[] | null;
+}, additionalTopLevelExcludeMap?: Readonly<Record<string, boolean>>): TItem[] | null;

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

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

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

@@ -0,0 +1,36 @@
+/**
+ * Sign in with OpenRouter (OAuth PKCE).
+ *
+ * No client registration: the S256 PKCE challenge is the only proof of
+ * identity. The browser authorizes at `https://openrouter.ai/auth`, redirects
+ * back to the loopback callback with `?code=`, and the code + verifier
+ * exchange at `/api/v1/auth/keys` mints a durable `sk-or-…` API key.
+ *
+ * OpenRouter never echoes a `state` parameter (the redirect only appends
+ * `?code=` to the callback URL), so the flow runs with an empty expected
+ * state — callback-state validation is disabled and the PKCE verifier binds
+ * the exchange instead.
+ *
+ * The manual-input race doubles as the API-key paste path: pasted `sk-or-…`
+ * keys skip the PKCE exchange and are validated against `/api/v1/auth/key`
+ * (the canonical "who am I" endpoint — `/api/v1/models` returns 200 for any
+ * bearer), so one login entry covers both browser sign-in and key paste.
+ */
+import type { FetchImpl } from "../../types.js";
+import { OAuthCallbackFlow } from "./callback-server.js";
+import type { OAuthController, OAuthCredentials } from "./types.js";
+/** Exchange an authorization code + PKCE verifier for a durable OpenRouter API key. */
+export declare function exchangeOpenRouterCode(code: string, codeVerifier: string, fetchImpl?: FetchImpl): Promise<string>;
+export declare class OpenRouterOAuthFlow extends OAuthCallbackFlow {
+    #private;
+    constructor(ctrl: OAuthController);
+    /** OpenRouter never echoes `state`; empty state disables callback-state validation. */
+    generateState(): string;
+    generateAuthUrl(_state: string, redirectUri: string): Promise<{
+        url: string;
+        instructions?: string;
+    }>;
+    exchangeToken(code: string): Promise<OAuthCredentials>;
+}
+/** Log in with Sign in with OpenRouter (PKCE); mints a durable API key. */
+export declare function loginOpenRouterOAuth(ctrl: OAuthController): Promise<OAuthCredentials>;

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

@@ -1,13 +1,14 @@
 import type { OAuthLoginCallbacks } from "./oauth/types.js";
-/** OpenRouter login flow (API key paste, validated via /auth/key).
- *
- * `/api/v1/models` is public and returns 200 for any bearer (including bogus),
- * so it cannot validate auth. `/api/v1/auth/key` is the canonical "who am I"
- * endpoint — 200 for valid keys, 401 otherwise.
+/**
+ * OpenRouter login: Sign in with OpenRouter (OAuth PKCE) that mints a durable
+ * `sk-or-…` API key, with the manual-input race accepting a pasted existing
+ * key (validated via `/api/v1/auth/key`). Either path resolves to a plain API
+ * key string, stored as an `api_key` credential.
  */
-export declare const loginOpenRouter: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const openrouterProvider: {
     readonly id: "openrouter";
     readonly name: "OpenRouter";
     readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+    readonly callbackPort: 54549;
+    readonly pasteCodeFlow: true;
 };

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

@@ -82,6 +82,10 @@ declare const ALL: ({
     readonly name: "Cursor (Claude, GPT, etc.)";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<import("./oauth/index.js").OAuthCredentials>;
     readonly refreshToken: (credentials: import("./oauth/index.js").OAuthCredentials) => Promise<import("./oauth/index.js").OAuthCredentials>;
+} | {
+    id: "deepinfra";
+    name: string;
+    login: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 } | {
     readonly id: "deepseek";
     readonly name: "DeepSeek";
@@ -254,6 +258,8 @@ declare const ALL: ({
     readonly id: "openrouter";
     readonly name: "OpenRouter";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+    readonly callbackPort: 54549;
+    readonly pasteCodeFlow: true;
 } | {
     readonly id: "parallel";
     readonly name: "Parallel";
@@ -342,6 +348,10 @@ declare const ALL: ({
     readonly id: "xiaomi-token-plan-sgp";
     readonly name: "Xiaomi Token Plan (Singapore)";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    readonly id: "yolo-auto";
+    readonly name: "Yolo-Auto";
+    readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "zai";
     readonly name: "Z.AI (GLM Coding Plan)";

package/dist/types/registry/yolo-auto.d.ts

@@ -0,0 +1,15 @@
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
+/**
+ * Yolo-Auto login flow (API key paste, validated via `/v1/models`).
+ *
+ * Yolo-Auto is a flat-rate OpenAI-compatible API. `GET /v1/models` 401s any
+ * missing or invalid bearer (verified against the live endpoint), so it doubles
+ * as the canonical "who am I" check — the same role OpenRouter's `/auth/key`
+ * plays there.
+ */
+export declare const loginYoloAuto: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+export declare const yoloAutoProvider: {
+    readonly id: "yolo-auto";
+    readonly name: "Yolo-Auto";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+};

package/dist/types/utils/empty-completion-retry.d.ts

@@ -8,15 +8,24 @@ export declare const EMPTY_COMPLETION_BASE_DELAY_MS = 500;
  * — or one that only ever produced thinking — is the "empty response" failure.
  */
 export declare function hasVisibleAssistantContent(message: AssistantMessage): boolean;
-interface EmptyCompletionRetryOptions {
+interface StreamRetryOptions {
     signal?: AbortSignal;
     providerRetryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
     acceptEmptyResponse?: boolean;
 }
+/** Controls which replay-safe provider results may issue a fresh request. */
+export interface ReplaySafeStreamRetryPolicy {
+    /** Retry benign terminal stops that contain no visible output. */
+    retryEmptyCompletion?: boolean;
+    /** Retry transient provider errors before output is committed. */
+    retryProviderErrors?: boolean;
+    /** Maximum transient provider-error retries; empty completions keep their shared fixed budget. */
+    maxProviderErrorRetries?: number;
+}
 /**
- * Wrap a single-attempt provider stream with bounded empty-completion retries.
- * `attempt` MUST create a fresh request (and its own output message) on each
- * call so a retry never inherits stale metadata from an empty attempt.
+ * Re-issues a fresh provider request only while the current attempt remains
+ * replay-safe. Buffered pre-output events from discarded attempts never reach
+ * consumers.
  */
-export declare function withEmptyCompletionRetry<M, O extends EmptyCompletionRetryOptions>(model: M, context: Context, options: O | undefined, attempt: (model: M, context: Context, options?: O) => AssistantMessageEventStream): AssistantMessageEventStream;
+export declare function withReplaySafeStreamRetry<M, O extends StreamRetryOptions>(model: M, context: Context, options: O | undefined, attempt: (model: M, context: Context, options?: O) => AssistantMessageEventStream, policy: ReplaySafeStreamRetryPolicy): AssistantMessageEventStream;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@linxiraos/pi-ai",
-	"version": "1.1.4",
+	"version": "1.1.5",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://linxira-os.github.io/zeta/",
 	"author": "Can Boluk",
@@ -37,10 +37,10 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@linxiraos/pi-omptype": "1.1.4",
-		"@linxiraos/pi-catalog": "1.1.4",
-		"@linxiraos/pi-utils": "1.1.4",
-		"@linxiraos/pi-wire": "1.1.4"
+		"@linxiraos/pi-omptype": "1.1.5",
+		"@linxiraos/pi-catalog": "1.1.5",
+		"@linxiraos/pi-utils": "1.1.5",
+		"@linxiraos/pi-wire": "1.1.5"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"