@linxiraos/pi-ai 1.1.23 → 1.1.24

package/CHANGELOG.md

@@ -2,8 +2,7 @@
 
 ## [Unreleased]
 
-## [1.1.23] - 2026-10-01
+## [1.1.24] - 2026-10-03
 
-## [1.1.22] - 2026-09-30
+- 网关身份头统一 `x-zeta-*`（消费方同步）；新增 `extractHttpStatusFromError`/`extractRetryHint` 导出。
 
-- 随 1.1.22 版本线发布;无面向用户的行为变化。

package/THIRD-PARTY-NOTICES.txt

@@ -1,7 +1,7 @@
-OMP THIRD-PARTY NOTICES
+ZETA THIRD-PARTY NOTICES
 =======================
 
-This generated, self-contained aggregate accompanies OMP release artifacts.
+This generated, self-contained aggregate accompanies Zeta release artifacts.
 It does not replace package-level license files. First-party licensing grants
 no rights in third-party code, fonts, data, or marks identified below.
 
@@ -1046,7 +1046,7 @@ These packages participate only in generation/web build tooling and are not ship
 
 SCOPED NON-PERMISSIVE PACKAGES
 ------------------------------
-The exact @img/sharp-libvips-* 1.2.4 all-target family is LGPL-3.0-or-later. It is not distributed in OMP npm bundles or standalone assets: @huggingface/transformers is always external, installed into a user-side versioned runtime on demand, and sharp is stubbed for speech/text. The dynamically loaded native library remains replaceable. Corresponding source is available from https://github.com/lovell/sharp-libvips.git and upstream libvips sources.
+The exact @img/sharp-libvips-* 1.2.4 all-target family is LGPL-3.0-or-later. It is not distributed in Zeta npm bundles or standalone assets: @huggingface/transformers is always external, installed into a user-side versioned runtime on demand, and sharp is stubbed for speech/text. The dynamically loaded native library remains replaceable. Corresponding source is available from https://github.com/lovell/sharp-libvips.git and upstream libvips sources.
 
 lightningcss 1.32.0 and its exact target leaves are MPL-2.0 build-only dependencies. MPL is not globally allowed and these packages are absent from runtime artifacts.
 

package/dist/types/auth/affinity.d.ts

@@ -26,6 +26,11 @@ export declare class SessionAffinity implements SessionsApi {
      * `lastUsedAtMs` backdates the sticky (session-file pin restores on resume);
      * it defaults to now for live selections. Automatic re-recording of the same
      * durable row preserves an explicit user pin.
+     *
+     * The in-memory sticky is always exact. The persisted row is rewritten only
+     * when the credential, its type, or explicitness changes, or when the stored
+     * last-use drifts by {@link SESSION_STICKY_PERSIST_INTERVAL_MS} — per-request
+     * rewrites were pure database churn.
      */
     record(provider: string, sessionId: string | undefined, type: AuthCredential["type"], index: number, lastUsedAtMs?: number, explicit?: boolean): void;
     /** Retrieves the last credential used by a session. */

package/dist/types/auth/cascade.d.ts

@@ -2,7 +2,7 @@ import { type ApiKeyResolver, type ResolvedApiKey } from "../auth-retry.js";
 import type { SessionAffinity } from "./affinity.js";
 import type { CredentialPool } from "./pool.js";
 import type { CredentialSelector } from "./select.js";
-import type { AuthApiKeyOptions, AuthCredential, AuthSource, AuthSourceOptions, KeysApi, LimitsApi } from "./types.js";
+import type { AuthApiKeyOptions, AuthCredential, AuthSource, AuthSourceOptions, KeysApi, LimitsApi, OAuthRequestIdentity } from "./types.js";
 /** Runtime (--api-key) and config (models.yml) key overrides plus the config-value resolver. */
 export declare class KeyOverrides {
     #private;
@@ -10,6 +10,8 @@ export declare class KeyOverrides {
     has(provider: string): boolean;
     runtimeKey(provider: string): string | undefined;
     configKey(provider: string): string | undefined;
+    /** Config value consulted only after stored OAuth/login credentials. */
+    fallbackKey(provider: string): string | undefined;
     /** Resolve a config value (env var name, "!command", literal) to the secret. */
     resolve(config: string): Promise<string | undefined>;
     /**
@@ -30,10 +32,17 @@ export declare class KeyOverrides {
      *
      * Lower priority than {@link KeyOverrides.setRuntime} so a CLI `--api-key`
      * still wins for the duration of a single invocation.
+     *
+     * `fallback: true` instead ranks the value below stored OAuth and `/login`
+     * credentials (at the env-var tier). Providers that own a `/login` flow use
+     * this so their default key reference (e.g. an unset env-var name, which
+     * resolves to its literal text) cannot shadow the key the user logged in with.
      */
-    setConfig(provider: string, apiKeyConfig: string): void;
+    setConfig(provider: string, apiKeyConfig: string, options?: {
+        fallback?: boolean;
+    }): void;
     /**
-     * Remove a single config-sourced API key override.
+     * Remove a single config-sourced API key (override or fallback).
      */
     removeConfig(provider: string): void;
     /**
@@ -85,7 +94,7 @@ export declare class KeyCascade implements KeysApi {
     /**
      * Classify where a provider's auth comes from, following the same precedence
      * as {@link KeyCascade.get}: runtime override → config override →
-     * stored OAuth → login-stored api_key → env var → stored api_key.
+     * stored OAuth → login-stored api_key → config fallback → env var → stored api_key.
      * Returns undefined when no auth is configured.
      *
      * Compact, structured counterpart to {@link KeyCascade.describe}; `env`
@@ -107,7 +116,7 @@ export declare class KeyCascade implements KeysApi {
      * Priority (first match wins): runtime override, config override, OAuth,
      * login API key, environment variable, then another stored API key.
      */
-    get(provider: string, sessionId?: string, options?: AuthApiKeyOptions, onCredentialId?: (id: number) => void): Promise<string | undefined>;
+    get(provider: string, sessionId?: string, options?: AuthApiKeyOptions, onCredentialId?: (id: number, identity?: OAuthRequestIdentity) => void): Promise<string | undefined>;
     /**
      * Build an {@link ApiKeyResolver} backed by this storage, implementing the
      * central a/b/c auth-retry policy:
@@ -140,7 +149,9 @@ export declare class KeyCascade implements KeysApi {
     describe(provider: string, sessionId?: string): string | undefined;
     setRuntime(provider: string, apiKey: string): void;
     removeRuntime(provider: string): void;
-    setConfig(provider: string, apiKeyConfig: string): void;
+    setConfig(provider: string, apiKeyConfig: string, options?: {
+        fallback?: boolean;
+    }): void;
     removeConfig(provider: string): void;
     clearConfig(): void;
     setResolver(resolver: (config: string) => Promise<string | undefined>): void;

package/dist/types/auth/pool.d.ts

@@ -46,10 +46,10 @@ export declare class CredentialPool implements CredentialsApi {
     /**
      * Adopt credentials another process committed before selecting or rotating.
      *
-     * The store is shared across every omp process, but the pool is an
+     * The store is shared across every zeta process, but the pool is an
      * in-process cache refreshed only by this process's own writes. Without
      * this a long-running session ranks a stale pool for its whole lifetime:
-     * `omp auth` in another terminal is invisible, rotation reports no usable
+     * `zeta-c auth` in another terminal is invisible, rotation reports no usable
      * sibling while a freshly added account sits unblocked in SQLite, and the
      * turn degrades to the fallback chain. The auth-broker path already polls;
      * direct-store sessions had no equivalent.
@@ -116,7 +116,9 @@ export declare class CredentialPool implements CredentialsApi {
     /**
      * Persist a refreshed credential by id only while the row still matches this
      * process's snapshot. A peer rotation wins the CAS and is reloaded instead of
-     * being overwritten after this process releases its refresh lease.
+     * being overwritten after this process releases its refresh lease. An
+     * unchanged credential still runs the CAS check (stores skip rewriting
+     * identical bytes), so peer rotations are detected without churning the row.
      *
      * Returns the row's current index, or -1 when it was disabled or removed.
      */
@@ -176,7 +178,7 @@ export declare class CredentialPool implements CredentialsApi {
      */
     snapshot(): AuthCredentialSnapshot;
     /**
-     * Disabled credential tombstones for display surfaces (`omp usage`,
+     * Disabled credential tombstones for display surfaces (`zeta-c usage`,
      * broker `GET /v1/credentials/disabled`). Empty when the backing store
      * keeps no tombstones or the remote broker predates the endpoint.
      */
@@ -185,7 +187,7 @@ export declare class CredentialPool implements CredentialsApi {
      * Force the backing store to revalidate its credential snapshot, then
      * reload. Remote broker stores re-fetch the snapshot; local stores are
      * always current, so only the reload runs. Callers that pair live
-     * per-credential data with stored identities (`omp usage`) use this so a
+     * per-credential data with stored identities (`zeta-c usage`) use this so a
      * disk-cached snapshot cannot misattribute fresh reports.
      */
     revalidate(): Promise<void>;

package/dist/types/auth/rank.d.ts

@@ -18,6 +18,11 @@ export type UsageCandidate<T extends AuthCredential> = {
     inReserve?: boolean;
     /** True only when reserve ranking had a usable remaining-fraction measurement. */
     reserveMeasured?: boolean;
+    /**
+     * Present after ranking: the account's renewable allowance for this request is
+     * spent, so if it still serves it draws on paid overage such as Codex credits.
+     */
+    allowanceSpent?: boolean;
 };
 /** OAuth credential eligible for usage ranking. */
 export type OAuthCandidate = UsageCandidate<OAuthCredential>;
@@ -35,6 +40,7 @@ export type UsageRankedCandidate<T extends AuthCredential> = UsageCandidate<T> &
     reserveMeasured?: boolean;
     accountPriority: number;
     hasPriorityBoost: boolean;
+    allowanceSpent: boolean;
     usageMeasured: boolean;
     planPriority: number;
     secondaryUsed: number;
@@ -49,5 +55,5 @@ export type RankedOAuthCandidate = UsageRankedCandidate<OAuthCredential>;
 export type RankedApiKeyCandidate = UsageRankedCandidate<ApiKeyCredential>;
 /** Rank accounts by model-plan eligibility when a plan gate applies. */
 export declare function planPriority(gate: PlanGate | undefined, report: UsageReport | null): number;
-/** Sort ranked candidates by blocks, plan, reserve, boost, hot window, usage and drain. */
+/** Sort ranked candidates by blocks, plan, spent allowance, reserve, boost, hot window, usage and drain. */
 export declare function orderUsageRankedCandidates<T extends AuthCredential>(candidates: UsageRankedCandidate<T>[], planGated: boolean): UsageCandidate<T>[];

package/dist/types/auth/refresh.d.ts

@@ -17,6 +17,13 @@ import { type AuthCredentialSnapshotEntry, type AuthStorageOptions, type OAuthCr
  * the rotation cadence by <4%.
  */
 export declare const OAUTH_REFRESH_SKEW_MS = 60000;
+type OrganizationScope = Pick<OAuthCredentials, "orgId" | "region" | "inferenceRegion" | "activeOrganizationId" | "orgName">;
+/**
+ * Organization-scoped identity after a refresh: refreshed values win; stored
+ * org/residency/inference scope carries over only while the organization is
+ * unchanged. The WorkOS selection always falls back to the stored one.
+ */
+export declare function mergeRefreshedOrganizationScope(current: OrganizationScope, refreshed: OrganizationScope): OrganizationScope;
 /** Merge provider refresh bytes with the stored OAuth row, preserving subtype metadata for every refresh path. */
 export declare function mergeRefreshedCredential<T extends OAuthCredential>(current: T, refreshed: OAuthCredentials): T;
 /** Dependencies for lease-guarded OAuth refresh. */
@@ -57,3 +64,4 @@ export declare class OAuthRefresher {
      */
     refreshById(id: number, signal?: AbortSignal, options?: OAuthRefreshByIdOptions): Promise<AuthCredentialSnapshotEntry>;
 }
+export {};

package/dist/types/auth/sqlite-credential-store.d.ts

@@ -36,6 +36,11 @@ export declare class SqliteAuthCredentialStore implements AuthCredentialStore {
     listDisabledCredentials(provider?: string): Promise<DisabledCredentialSummary[]>;
     replaceAuthCredentials(provider: string, credentials: AuthCredential[]): Promise<StoredAuthCredential[]>;
     upsertAuthCredential(provider: string, credential: AuthCredential): Promise<StoredAuthCredential[]>;
+    /**
+     * Rewrites a row only when its persisted bytes change: an identical write would
+     * still bump `updated_at` and `auth_change_revision`, making every peer process
+     * reload credentials for nothing.
+     */
     updateAuthCredential(id: number, credential: AuthCredential): void;
     tryUpdateAuthCredentialIfMatches(id: number, expectedData: string, credential: AuthCredential, lease?: CredentialRefreshLeaseFence): boolean;
     deleteAuthCredential(id: number, disabledCause: string): Promise<boolean>;

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

@@ -80,7 +80,7 @@ export interface StoredCredentialBlock {
 /**
  * Identity slice of a disabled (soft-deleted) credential tombstone — cause and
  * account identity only, never token material. Surfaced so auto-disabled
- * accounts (e.g. an expired Anthropic OAuth grant) stay visible in `omp usage`
+ * accounts (e.g. an expired Anthropic OAuth grant) stay visible in `zeta-c usage`
  * instead of silently vanishing until the user notices missing quota.
  */
 export interface DisabledCredentialSummary {
@@ -180,6 +180,9 @@ export type CompletionProbeCredential = {
     email?: string;
     enterpriseUrl?: string;
     apiEndpoint?: string;
+    orgId?: string;
+    region?: string;
+    inferenceRegion?: "global" | "eu" | "us";
 };
 /**
  * Caller-supplied bearer probe. Receives the post-refresh credential for a
@@ -318,7 +321,7 @@ export type AuthStorageOptions = {
      *
      * Examples:
      * - `"local ~/.zeta/agent/agent.db"`
-     * - `"broker http://omp.internal:8765"`
+     * - `"broker http://zeta.internal:8765"`
      */
     sourceLabel?: string;
 };
@@ -422,6 +425,12 @@ export type AuthApiKeyOptions = {
     /** Explicit provider-401 recovery; generic force refreshes leave this unset. */
     refreshReason?: OAuthRefreshReason;
 };
+/** Non-secret identity bound to the OAuth credential selected for one request attempt. */
+export interface OAuthRequestIdentity {
+    orgId?: string;
+    region?: string;
+    inferenceRegion?: "global" | "eu" | "us";
+}
 /**
  * Refreshed OAuth access plus identity metadata returned by
  * {@link AuthStorage.oauth.access}. Callers that authenticate via a bearer
@@ -441,6 +450,8 @@ export interface OAuthAccess {
     /** Organization/workspace the credential is scoped to (Anthropic/ChatGPT multi-subscription). */
     orgId?: string;
     orgName?: string;
+    region?: string;
+    inferenceRegion?: "global" | "eu" | "us";
 }
 /**
  * Identity slice of the credential a successful {@link AuthStorage.oauth.login}
@@ -504,6 +515,8 @@ export interface OAuthAccountSummary {
     orgName?: string;
     /** True when this account is the session-sticky OAuth credential requested by `listOAuthAccounts`. */
     active: boolean;
+    /** Last use recorded on the session sticky; set only on the `active` account. */
+    lastUsedAtMs?: number;
 }
 /** Scope a matching-key invalidation to a session or signal. */
 export interface InvalidateCredentialMatchingOptions {
@@ -710,7 +723,7 @@ export interface CredentialsApi {
      * Force the backing store to revalidate its credential snapshot, then
      * reload. Remote broker stores re-fetch the snapshot; local stores are
      * always current, so only the reload runs. Callers that pair live
-     * per-credential data with stored identities (`omp usage`) use this so a
+     * per-credential data with stored identities (`zeta-c usage`) use this so a
      * disk-cached snapshot cannot misattribute fresh reports.
      */
     revalidate(): Promise<void>;
@@ -769,7 +782,7 @@ export interface CredentialsApi {
      */
     disable(id: number, disabledCause: string): Promise<boolean>;
     /**
-     * Disabled credential tombstones for display surfaces (`omp usage`,
+     * Disabled credential tombstones for display surfaces (`zeta-c usage`,
      * broker `GET /v1/credentials/disabled`). Empty when the backing store
      * keeps no tombstones or the remote broker predates the endpoint.
      */
@@ -848,10 +861,16 @@ export interface KeysApi {
      *
      * Lower priority than {@link setRuntimeApiKey} so a CLI `--api-key`
      * still wins for the duration of a single invocation.
+     *
+     * `fallback: true` ranks the value below stored OAuth and `/login`
+     * credentials instead, so a provider's default key reference cannot shadow
+     * a key the user logged in with.
      */
-    setConfig(provider: string, apiKeyConfig: string): void;
+    setConfig(provider: string, apiKeyConfig: string, options?: {
+        fallback?: boolean;
+    }): void;
     /**
-     * Remove a single config-sourced API key override.
+     * Remove a single config-sourced API key (override or fallback).
      */
     removeConfig(provider: string): void;
     /**

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

@@ -0,0 +1,12 @@
+/**
+ * Auth-broker wire-protocol helpers shared by the server and the client store.
+ */
+import type { CredentialBlockSnapshot } from "./types.js";
+/** Parse a snapshot `ETag` / `If-None-Match` value (`"N"`, `W/"N"`, or bare `N`) into a generation. */
+export declare function parseGenerationTag(header: string | null): number | undefined;
+/**
+ * Canonical order for a credential's block snapshots. The server and the client
+ * store both sort with it, because block lists are compared positionally; the
+ * `updatedAtMs` tiebreak keeps otherwise-identical blocks in one stable order.
+ */
+export declare function compareCredentialBlockSnapshots(a: CredentialBlockSnapshot, b: CredentialBlockSnapshot): number;

package/dist/types/auth-gateway/dispatch.d.ts

@@ -1,4 +1,4 @@
-import type { ApiKeyResolver } from "../auth-retry.js";
+import type { ApiKeyResolver, ResolvedApiKey } from "../auth-retry.js";
 import type { AuthStorage } from "../auth-storage.js";
 import { type GatewayErrorClassification } from "../error/gateway.js";
 import type { Api, FetchImpl, Model, Usage } from "../types.js";
@@ -42,12 +42,12 @@ export declare function resolveGatewayAccount(storage: AuthStorage, provider: st
  * Resolve the credential for one request from broker-backed storage.
  *
  * pi-ai clients never consult `AuthStorage`; the gateway resolves the bearer
- * (an OAuth access token refreshed through the broker when needed) and hands
- * it to the client. Returns the key, or the error classification the route
- * should encode in its own envelope: storage failures map through
- * {@link classifyGatewayError}, a provider without any credential is a 401.
+ * and its OAuth identity together (refreshing through the broker when needed).
+ * Keep this selection snapshot intact even if another request replaces the
+ * stored token before dispatch. Storage failures map through
+ * {@link classifyGatewayError}; a provider without any credential is a 401.
  */
-export declare function resolveGatewayApiKey(storage: AuthStorage, model: Model<Api>, sessionId: string, signal: AbortSignal, peer: string): Promise<string | GatewayErrorClassification>;
+export declare function resolveGatewayApiKey(storage: AuthStorage, model: Model<Api>, sessionId: string, signal: AbortSignal, peer: string): Promise<ResolvedApiKey | GatewayErrorClassification>;
 /**
  * Build the {@link ApiKeyResolver} handed to a pi-ai client for a gateway
  * request. Drives the central a/b/c auth-retry policy server-side:
@@ -63,7 +63,7 @@ export declare function resolveGatewayApiKey(storage: AuthStorage, model: Model<
  * routes that retain provider session state use it to re-key the account
  * lease, one-shot routes pass `undefined`.
  */
-export declare function buildGatewayApiKeyResolver(storage: AuthStorage, model: Model<Api>, sessionId: string, initialKey: string, requestSignal: AbortSignal, format: string, peer: string, onResolvedKey?: (apiKey: string) => void): ApiKeyResolver;
+export declare function buildGatewayApiKeyResolver(storage: AuthStorage, model: Model<Api>, sessionId: string, initialKey: ResolvedApiKey, requestSignal: AbortSignal, format: string, peer: string, onResolvedKey?: (apiKey: string) => void): ApiKeyResolver;
 /**
  * Attribute one settled upstream request to the originating client via the
  * broker's observed-usage channel (`AuthStorage.usage.observe`, batched

package/dist/types/auth-gateway/http.d.ts

@@ -16,7 +16,10 @@ export declare function gatewayResponseHeaders(model: Model<Api>, info: {
     costUsd?: number;
     startedAt?: number;
 }): Record<string, string>;
-export declare function resolvePeer(req: Request): string;
+/** Use the socket peer unless the gateway explicitly trusts its reverse proxy. */
+export declare function resolvePeer(req: Request, socketAddress: string, trustProxyHeaders?: boolean): string;
+/** Keep configured gateway credentials out of URL and forwarded/logged request fields. */
+export declare function hasMisplacedBearer(req: Request, url: URL, tokens: ReadonlySet<string>): boolean;
 /**
  * Constant-time byte comparison. Falls back to a manual XOR accumulator if
  * `node:crypto.timingSafeEqual` isn't available. Always processes every byte
@@ -33,8 +36,8 @@ export declare function captureRequestHeaders(headers: Headers): Record<string,
 /**
  * Resolve the usage-attribution identity for an inbound gateway request.
  *
- * pi-native omp clients send `x-omp-install-id` / `x-omp-hostname` /
- * `x-omp-app` (see `providers/pi-native-client.ts`); any client may set them.
+ * pi-native zeta clients send `x-zeta-install-id` / `x-zeta-hostname` /
+ * `x-zeta-app` (see `providers/pi-native-client.ts`); any client may set them.
  * Requests without an install id fall back to the gateway host's identity
  * under the `gateway` app label, so unlabeled foreign-SDK traffic (llm-git,
  * openai/anthropic SDKs) still lands in per-client burn tracking instead of

package/dist/types/auth-gateway/server.d.ts

@@ -1,12 +1,12 @@
 /**
- * omp auth-gateway HTTP server.
+ * zeta-c auth-gateway HTTP server.
  *
  * Accepts any provider-format request (OpenAI chat-completions, Anthropic
  * messages, OpenAI Responses) and dispatches through pi-ai's `streamSimple()`
  * — which handles credential injection, anthropic-beta headers, codex
  * websocket transport, and all the per-provider intricacies. The gateway is
- * pure protocol translation: foreign wire → omp Context → pi-ai stream() →
- * omp events → foreign wire.
+ * pure protocol translation: foreign wire → zeta Context → pi-ai stream() →
+ * zeta events → foreign wire.
  *
  * Endpoints:
  *   GET  /healthz                          → unauth; ok + version

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

@@ -1,9 +1,9 @@
 import type { Effort } from "@linxiraos/pi-catalog/effort";
 import type { AssistantMessage, AssistantMessageEventStream, CacheRetention, Context, OpenAIResponseInclude, ServiceTier, TokenTaskBudget } from "../types.js";
 /**
- * Wire types for the omp auth-gateway.
+ * Wire types for the zeta-c auth-gateway.
  *
- * The gateway sits between unauthenticated clients (containerized omp,
+ * The gateway sits between unauthenticated clients (containerized zeta,
  * llm-git, …) and the broker. It accepts provider-format HTTP requests
  * (OpenAI chat-completions / Anthropic messages / OpenAI Responses),
  * dispatches them through pi-ai's `streamSimple()`, and translates the
@@ -125,6 +125,8 @@ export interface AuthGatewayServerOptions {
     bind?: string;
     /** Accept any of these bearer tokens. Empty allows unauthenticated calls. */
     bearerTokens: string[];
+    /** Honor forwarded peer headers only when the connecting proxy is trusted. Default false. */
+    trustProxyHeaders?: boolean;
     /** Version surfaced on `/healthz`. */
     version?: string;
 }

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

@@ -1,4 +1,4 @@
-import type { LimitsApi, OAuthAccess, OAuthApi } from "./auth/types.js";
+import type { LimitsApi, OAuthAccess, OAuthApi, OAuthRequestIdentity } from "./auth/types.js";
 import { isAuthRetryableError } from "./error/auth-classify.js";
 /**
  * Context passed to an {@link ApiKeyResolver} on each resolution attempt.
@@ -42,6 +42,8 @@ export interface ResolvedApiKey {
      * already sent it before that block.
      */
     afterSiblingWait?: boolean;
+    /** Non-secret request scope belonging to this bearer, replaced on account rotation. */
+    oauthIdentity?: OAuthRequestIdentity;
 }
 export type ApiKeyResolution = string | ResolvedApiKey | undefined;
 export type ApiKeyResolver = (ctx: ApiKeyResolveContext) => Promise<ApiKeyResolution> | ApiKeyResolution;

package/dist/types/dialect/rendering.d.ts

@@ -1,4 +1,5 @@
 import type { AssistantMessage, Message, ToolCall } from "../types.js";
+import { type ToolArgShape } from "./coercion.js";
 import type { DialectRenderOptions, DialectToolResult } from "./types.js";
 export declare function renderToolResponseResults(results: readonly DialectToolResult[]): string;
 export declare function kimiCallId(name: string, id: string, index: number): string;
@@ -15,6 +16,9 @@ export declare function pyCall(name: string, args: Record<string, unknown>): str
 export declare function pyValue(value: unknown): string;
 export declare function escapeXmlAttr(value: string): string;
 export declare function escapeXmlText(value: string): string;
+/** Render one Anthropic-style `<invoke>`; declared string args stay raw, everything else is JSON. */
+export declare function renderInvoke(call: ToolCall, shape: ToolArgShape | undefined): string;
+export declare function renderInvokes(calls: readonly ToolCall[], tools: NonNullable<DialectRenderOptions["tools"]>): string;
 export type AssistantTranscriptParts = {
     readonly text: string;
     readonly thinking: string;

package/dist/types/images/shared.d.ts

@@ -10,9 +10,11 @@ export declare function usageFromWire(value: unknown): Usage;
 export declare function imageBaseUrl(model: Model): string;
 export declare function modelHeaders(model: Model, signal?: AbortSignal): Promise<Record<string, string>>;
 export declare function errorMessage(rawText: string): string;
+/** Request URL, or a builder for routes that depend on the bearer (xAI's `XAI_BASE_URL` rule). */
+type ImageRequestUrl = string | ((bearer: string) => string);
 export declare function postJson(options: {
     model: Model;
-    url: string;
+    url: ImageRequestUrl;
     body: unknown;
     apiKey: ApiKey;
     fetch: FetchImpl;
@@ -20,7 +22,7 @@ export declare function postJson(options: {
 }): Promise<unknown>;
 export declare function postMultipart(options: {
     model: Model;
-    url: string;
+    url: ImageRequestUrl;
     body: FormData;
     apiKey: ApiKey;
     fetch: FetchImpl;
@@ -32,3 +34,4 @@ export declare function decodeImageResponse(value: unknown, fetch: FetchImpl, si
 }>;
 export declare function toDataUrl(image: GeneratedImage): string;
 export declare function resolveOpenAIImageSize(aspectRatio?: string, imageSize?: string): string | undefined;
+export {};

package/dist/types/index.d.ts

@@ -45,6 +45,7 @@ export * from "./usage.js";
 export * from "./usage/claude.js";
 export * from "./usage/claude-reset.js";
 export * from "./usage/cursor.js";
+export * from "./usage/factory-droid.js";
 export * from "./usage/gemini.js";
 export * from "./usage/github-copilot.js";
 export * from "./usage/google-antigravity.js";

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

@@ -225,7 +225,15 @@ export type ThinkingConfigAdaptive = {
     /** Preserved-thinking prefix mismatch policy. */
     block_binding?: ThinkingBlockBinding;
 };
-export type ThinkingConfigParam = ThinkingConfigEnabled | ThinkingConfigDisabled | ThinkingConfigAdaptive;
+/**
+ * Sonnet 5.5's replacement for `disabled`: no up-front thinking, progress
+ * updates between tool calls only. Takes no other field, and effort above
+ * `high` is rejected alongside it.
+ */
+export type ThinkingConfigBetweenTools = {
+    type: "between_tools";
+};
+export type ThinkingConfigParam = ThinkingConfigEnabled | ThinkingConfigDisabled | ThinkingConfigAdaptive | ThinkingConfigBetweenTools;
 export type OutputConfig = {
     /** Adaptive-thinking effort level (effort beta). */
     effort?: "low" | "medium" | "high" | "xhigh" | "max" | null;

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

@@ -217,13 +217,37 @@ type SystemBlockOptions = {
 export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
 export declare function normalizeExtraBetas(betas?: string[] | string): string[];
 export declare function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): AnthropicClientOptionsResult;
+/**
+ * True when enabled thinking on `model` is budget thinking
+ * (`thinking.type: "enabled"` with `budget_tokens`) rather than adaptive.
+ */
+export declare function usesBudgetThinking(model: Model<"anthropic-messages">): boolean;
+/** The most output tokens a request to `model` may ask for (`max_tokens` ceiling). */
+export declare function anthropicOutputLimit(model: Model<"anthropic-messages">): number;
+/**
+ * The `max_tokens` and thinking budget of budget thinking: `max_tokens`
+ * rises to leave {@link OUTPUT_FALLBACK_BUFFER} visible output tokens after
+ * the budget, within `maxAllowedTokens`, and the budget shrinks when that
+ * ceiling leaves less (a non-positive budget means the ceiling is too low).
+ */
+export declare function budgetThinkingOutput(maxTokens: number | undefined, budgetTokens: number, maxAllowedTokens: number): {
+    maxTokens: number;
+    budgetTokens: number;
+};
+/**
+ * Whether the conversation has stopped being thinking-led, so routes with
+ * `compat.stripThinkingHistory` drop the budget `thinking` config and replay
+ * history without thinking blocks. Exported so the factory-droid provider can
+ * gate its header-level interleaved beta on the same decision.
+ */
+export declare function shouldStripThinkingHistory(messages: readonly Message[]): boolean;
 /**
  * A single Anthropic conversation turn, including the mid-conversation
  * `system` role (Opus 4.8+ and Fable/Mythos 5).
  */
 export type AnthropicMessageParam = MessageParam;
 /**
- * Serialize omp {@link Message}s to Anthropic wire messages.
+ * Serialize zeta {@link Message}s to Anthropic wire messages.
  *
  * `opts.serverSideFallbackEnabled` — when the CURRENT request itself
  * opts into the server-side-fallback beta chain. Only then may a persisted

package/dist/types/providers/aws-sigv4.d.ts

@@ -33,6 +33,11 @@ export interface SignParams {
     /** Override clock for deterministic tests. */
     date?: Date;
 }
+/** Coerce a possibly-ArrayBufferLike-backed `Uint8Array` into one over a fresh
+ * `ArrayBuffer`, which is what `crypto.subtle.{digest,sign,importKey}` requires
+ * under the strict TS DOM typings. No-op when already strict.
+ */
+export declare function asStrict(bytes: Uint8Array): Uint8Array<ArrayBuffer>;
 export declare function toHex(bytes: Uint8Array): string;
 export declare function sha256(data: Uint8Array | string): Promise<Uint8Array>;
 export declare function sha256Hex(data: Uint8Array | string): Promise<string>;

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

@@ -0,0 +1,9 @@
+/**
+ * Fit an Anthropic request body to Bedrock's Anthropic Messages API
+ * (`compat.bedrockMessagesApi`): both `/anthropic` routes reject the tool
+ * `strict` field, and bedrock-runtime rejects a `metadata.user_id` outside
+ * Bedrock's request-metadata pattern. A user id that fits is kept, otherwise
+ * its embedded session id, otherwise the metadata is dropped. Mutates and
+ * returns `payload`.
+ */
+export declare function fitBedrockAnthropicPayload<T>(payload: T): T;

package/dist/types/providers/bedrock-request-metadata.d.ts

@@ -0,0 +1,2 @@
+/** Check Bedrock's request-metadata character and length limits. Keys must also be nonempty. */
+export declare function isBedrockRequestMetadataValue(value: string): boolean;

package/dist/types/providers/cursor/interaction-query.d.ts

@@ -1,5 +1,16 @@
-import type http2 from "node:http2";
 import { type InteractionQuery } from "@linxiraos/pi-catalog/discovery/cursor-proto";
+type ProtoUnknownField = {
+    no: number;
+    wireType: number;
+    data: Uint8Array;
+};
+interface CursorInteractionWriter {
+    write(frame: Uint8Array): void;
+}
+/** Wrap one Connect-protocol message: 1 flag byte + 4-byte big-endian length + payload. */
+export declare function frameConnectMessage(data: Uint8Array, flags?: number): Buffer;
+/** Well-formed protobuf-es `$unknown` entries on `message`; anything else on the bag is ignored. */
+export declare function protoUnknownFields(message: object): ProtoUnknownField[];
 /**
  * Answer a Cursor `interaction_query` so the Run RPC can continue.
  *
@@ -12,4 +23,5 @@ import { type InteractionQuery } from "@linxiraos/pi-catalog/discovery/cursor-pr
  * Unsupported interactive queries are rejected so the server is not stranded.
  * VM setup is left unanswered rather than reporting a fake success.
  */
-export declare function handleInteractionQuery(query: InteractionQuery, h2Request: http2.ClientHttp2Stream): void;
+export declare function handleInteractionQuery(query: InteractionQuery, h2Request: CursorInteractionWriter): void;
+export {};