@gajae-code/ai 0.18.10 → 0.18.12

package/CHANGELOG.md

@@ -2,6 +2,76 @@
 
 ## [Unreleased]
 
+## [0.18.12] - 2026-10-16
+
+### Added
+
+- Added the `org:<organization id or name>` credential selector, matching an OAuth credential by its organization id or display name (case-insensitive).
+
+- `AuthStorageOptions.credentialPreferences` accepts an ordered, persisted soft OAuth account preference list per provider (`ConfiguredCredentialPreference[]`: selector plus optional `maxUsedFraction` cap per entry). Selection uses the first listed account that is usable and under its cap; when every listed account is blocked or capped, the unlisted accounts are ranked by balanced/earliest-reset ranking, and capped listed accounts are used only after those. Caps read the windows each provider reports, so they also apply to providers without a ranking strategy. Runtime `--credential`/`--prefer-credential` selectors and session stickiness take precedence. A list whose entries name one stored row twice (for example an email and `account:<id>` for the same login) is ignored as a whole and reported by `AuthStorage.findDuplicateCredentialPreferences()`.
+
+- Add Gemini 4 Argon (`gemini-4-argon`) and send `thinkingLevel` (low/medium/high) for Gemini 4 models instead of falling back to `thinkingBudget`.
+
+- Custom `openai-responses` relays whose base URL has a loopback hostname (`127.0.0.0/8`, `localhost`, `::1`) now send `session_id`/`x-client-request-id` affinity headers without an explicit opt-in. The ChatGPT codex backend only reuses a warmed prompt prefix for requests that carry a session identity, so such a relay previously reported zero cached tokens and replayed the entire context on every turn. Remote relays stay opt-in, known non-OpenAI provider IDs stay excluded, retention `none` still suppresses the headers, and `compat.supportsResponsesSessionAffinity: false` opts a loopback relay back out.
+
+- Added `ultrafast` as a first-class ServiceTier option, alongside existing tiers (auto, default, flex, scale, priority)
+- Support for OpenAI's ultrafast processing tier on OpenAI chat completions and Codex responses APIs
+- 6x ultrafast multiplier for API token pricing (per OpenAI's official pricing: $60 input, $300 output for gpt-6-astra)
+- Ultrafast service tier now properly resolves and sends to supported models
+
+### Changed
+
+- Use User-Agent-aware Antigravity model-cache validation so discovery catalogs are refreshed for the active client identity.
+
+- `ServiceTier` type now includes "ultrafast" as a valid option
+- `shouldSendServiceTier()` now includes ultrafast in provider send logic for OpenAI
+- OpenAI chat server schema updated to accept "ultrafast" in service_tier field
+- Codex included-usage estimates use the official Fast 2.5x and Ultrafast 8x multipliers
+
+### Fixed
+
+- Kiro streams now surface explicit content-filter refusal messages with category and explanation instead of the generic "no tokens" error when a refusal is detected. Both bearer token (via `messageMetadataEvent`) and API-key (`ksk_`, via `metadataEvent`) paths are supported, with proper provider safety-stop minting. Bearer-token text streams incrementally unless a thinking block precedes it; API-key text remains quarantined until clean EOF. Tool calls are emitted only at stream end (#6150).
+- Detail-free `stopReason: "CONTENT_FILTERED"` (without `stopDetails.refusal` object) is now treated as a refusal and suppresses unconfirmed content.
+- API-key text remains quarantined through `COMPLETED`/`TOOL_USE` metadata and is released only at clean EOF, so a later refusal or read failure cannot leak content across HTTP chunk boundaries.
+- A refusal takes precedence over ordinary errors or successful completion in the same batch or a later read. An active tool may finish its input after `TOOL_USE`, while `COMPLETED` fences tool fragments and later content.
+- Error events omit duplicate partial messages so credential-shaped upstream text cannot bypass gateway redaction or leak through SSE encoders.
+- Parser no longer resyncs into nested objects when an incomplete outer JSON frame is encountered. Incomplete frames are retained as remainder; EOF with incomplete frame throws an error.
+- Errors before clean EOF discard quarantined text and retain only explicitly completed tool calls.
+
+- API-key validation now accepts successful inference responses that contain reasoning output or end at the token limit before producing text, and reports empty or missing choices accurately.
+
+- An image Anthropic rejects with `Could not process image` no longer makes every later request in the session fail. The provider replaces the rejected image with a text placeholder and keeps omitting it on later turns and fallback models. The first repair omits the images of the newest message that has any; if the request still fails, the second omits every image (#6810).
+
+- Anthropic OAuth keeps one stored credential per organization when a single account belongs to several organizations (for example a Team workspace and a personal Max plan). Credentials now record the organization from the token response, their identity key is scoped to it, so logging in to a second organization no longer replaces or disables the first, and usage limits are reported per organization instead of being merged across them. Rows stored before this change keep working and are deduplicated once their next refresh records the organization.
+
+- Broker usage reports are matched to a credential by the identity (account, email, or project) and Anthropic organization they carry, checked against the current broker snapshot. A report without a matching identity is taken only when the provider has a single stored OAuth credential, so a lone report is no longer assigned to every credential of a provider that holds several. A credential stored without an Anthropic organization never takes a report whose organization another stored credential is scoped to, so a legacy row whose own usage fetch fails gets no fresh usage data instead of another row's or another account's limits.
+- An `org:` selector that matches more than one stored credential (organizations sharing a display name) is rejected with the candidate row ids instead of resolving to the first row, and an exact organization-id match is preferred over display-name matches. Pin ambiguity errors now list the candidate row ids.
+
+- Keep cached models from a different User-Agent out of failed-refresh fallbacks, and report the effective User-Agent in discovery diagnostics.
+
+- Replace user and tool-result images with text markers for Bedrock models without image input, including consecutive tool results, while preserving image payloads for image-capable models.
+
+- `--prefer-credential` now selects the designated OAuth account when the provider also stores API-key rows. The preferred row was matched by its index in the full credential list against OAuth-only candidate indices, so a mixed pool could move a different OAuth account to the front.
+
+- OpenAI Responses and Completions streams now use a model's configured idle timeout when no environment or request override is set, so long reasoning gaps on compatible proxies can be tuned per model. Longer request-level idle windows also bound SDK setup before response headers arrive, and SDK timers are kept within the platform-safe range. Kimi Code's Anthropic-compatible route also honors its model timeout, with environment and request overrides retaining precedence.
+
+- Normalize negative and non-finite model catalog prices to zero so bundled usage estimates cannot become negative.
+
+- Switching the model cache to a different database path now fully releases the previous database. A migration query left an unfinalized prepared statement, so closing the old connection left it open in the background; it kept the database locked and, on Windows, blocked deleting its directory.
+
+- Omit MCP tool-result image payloads from Ollama chat requests when the model does not support image input, retaining a text omission marker.
+
+- Closing AuthStorage and the model cache now deterministically finalizes their owned SQLite statements before releasing the database, allowing immediate removal of owned scratch directories on Windows.
+
+- Usage pricing now follows provider-reported effective tiers when available, and gateway responses preserve that tier for downstream clients.
+
+### Notes
+
+- Ultrafast tier is currently available for gpt-6-astra and gpt-6.1-sol. The gpt-5.6-sol model is Fast-only and is not eligible for ultrafast.
+- For unsupported models, ultrafast is omitted and provider-default processing is used; no unsupported tier is sent.
+
+## [0.18.11] - 2026-10-12
+
 ## [0.18.10] - 2026-10-12
 
 ## [0.18.9] - 2026-10-11

package/README.md

@@ -782,7 +782,7 @@ interface OpenAICompat {
 	supportsStore?: boolean; // Whether provider supports the `store` field (default: true)
 	supportsDeveloperRole?: boolean; // Whether provider supports `developer` role vs `system` (default: true)
 	sendSessionHeaders?: boolean; // Forward the session id as `session_id`/`x-session-id` headers for relay session-affinity & prompt-cache reuse (default: false)
-	supportsResponsesSessionAffinity?: boolean; // Opt in to session-affinity headers for custom openai-responses relays; canonical OpenAI routing is automatic (default: false)
+	supportsResponsesSessionAffinity?: boolean; // Opt in to session-affinity headers for custom openai-responses relays; canonical OpenAI routing and loopback-hostname relays are automatic (default: false for remote relays)
 	supportsReasoningEffort?: boolean; // Whether provider supports `reasoning_effort` (default: true)
 	maxTokensField?: "max_completion_tokens" | "max_tokens"; // Which field name to use (default: max_completion_tokens)
 	extraBody?: Record<string, unknown>; // Extra request-body fields for custom proxy routing or provider-specific options

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

@@ -25,6 +25,8 @@ export declare const oauthCredentialSchema: z.ZodObject<{
     projectId: z.ZodOptional<z.ZodString>;
     email: z.ZodOptional<z.ZodString>;
     accountId: z.ZodOptional<z.ZodString>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    organizationName: z.ZodOptional<z.ZodString>;
     mcpBinding: z.ZodOptional<z.ZodObject<{
         resourceOrigin: z.ZodString;
         tokenEndpoint: z.ZodString;
@@ -39,6 +41,8 @@ export declare const remoteOauthCredentialSchema: z.ZodObject<{
     projectId: z.ZodOptional<z.ZodString>;
     email: z.ZodOptional<z.ZodString>;
     accountId: z.ZodOptional<z.ZodString>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    organizationName: z.ZodOptional<z.ZodString>;
     mcpBinding: z.ZodOptional<z.ZodObject<{
         resourceOrigin: z.ZodString;
         tokenEndpoint: z.ZodString;
@@ -59,6 +63,8 @@ export declare const writableAuthCredentialSchema: z.ZodDiscriminatedUnion<[z.Zo
     projectId: z.ZodOptional<z.ZodString>;
     email: z.ZodOptional<z.ZodString>;
     accountId: z.ZodOptional<z.ZodString>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    organizationName: z.ZodOptional<z.ZodString>;
     mcpBinding: z.ZodOptional<z.ZodObject<{
         resourceOrigin: z.ZodString;
         tokenEndpoint: z.ZodString;
@@ -76,6 +82,8 @@ export declare const snapshotCredentialSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     projectId: z.ZodOptional<z.ZodString>;
     email: z.ZodOptional<z.ZodString>;
     accountId: z.ZodOptional<z.ZodString>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    organizationName: z.ZodOptional<z.ZodString>;
     mcpBinding: z.ZodOptional<z.ZodObject<{
         resourceOrigin: z.ZodString;
         tokenEndpoint: z.ZodString;
@@ -96,6 +104,8 @@ export declare const credentialSnapshotEntrySchema: z.ZodObject<{
         projectId: z.ZodOptional<z.ZodString>;
         email: z.ZodOptional<z.ZodString>;
         accountId: z.ZodOptional<z.ZodString>;
+        organizationId: z.ZodOptional<z.ZodString>;
+        organizationName: z.ZodOptional<z.ZodString>;
         mcpBinding: z.ZodOptional<z.ZodObject<{
             resourceOrigin: z.ZodString;
             tokenEndpoint: z.ZodString;
@@ -119,6 +129,8 @@ export declare const snapshotEntrySchema: z.ZodObject<{
         projectId: z.ZodOptional<z.ZodString>;
         email: z.ZodOptional<z.ZodString>;
         accountId: z.ZodOptional<z.ZodString>;
+        organizationId: z.ZodOptional<z.ZodString>;
+        organizationName: z.ZodOptional<z.ZodString>;
         mcpBinding: z.ZodOptional<z.ZodObject<{
             resourceOrigin: z.ZodString;
             tokenEndpoint: z.ZodString;
@@ -160,6 +172,8 @@ export declare const snapshotResponseSchema: z.ZodObject<{
             projectId: z.ZodOptional<z.ZodString>;
             email: z.ZodOptional<z.ZodString>;
             accountId: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationName: z.ZodOptional<z.ZodString>;
             mcpBinding: z.ZodOptional<z.ZodObject<{
                 resourceOrigin: z.ZodString;
                 tokenEndpoint: z.ZodString;
@@ -223,6 +237,8 @@ export declare const snapshotStreamSnapshotEventSchema: z.ZodObject<{
             projectId: z.ZodOptional<z.ZodString>;
             email: z.ZodOptional<z.ZodString>;
             accountId: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationName: z.ZodOptional<z.ZodString>;
             mcpBinding: z.ZodOptional<z.ZodObject<{
                 resourceOrigin: z.ZodString;
                 tokenEndpoint: z.ZodString;
@@ -261,6 +277,8 @@ export declare const snapshotStreamEntryEventSchema: z.ZodObject<{
             projectId: z.ZodOptional<z.ZodString>;
             email: z.ZodOptional<z.ZodString>;
             accountId: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationName: z.ZodOptional<z.ZodString>;
             mcpBinding: z.ZodOptional<z.ZodObject<{
                 resourceOrigin: z.ZodString;
                 tokenEndpoint: z.ZodString;
@@ -312,6 +330,8 @@ export declare const snapshotStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodOb
             projectId: z.ZodOptional<z.ZodString>;
             email: z.ZodOptional<z.ZodString>;
             accountId: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationName: z.ZodOptional<z.ZodString>;
             mcpBinding: z.ZodOptional<z.ZodObject<{
                 resourceOrigin: z.ZodString;
                 tokenEndpoint: z.ZodString;
@@ -348,6 +368,8 @@ export declare const snapshotStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodOb
             projectId: z.ZodOptional<z.ZodString>;
             email: z.ZodOptional<z.ZodString>;
             accountId: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationName: z.ZodOptional<z.ZodString>;
             mcpBinding: z.ZodOptional<z.ZodObject<{
                 resourceOrigin: z.ZodString;
                 tokenEndpoint: z.ZodString;
@@ -453,6 +475,8 @@ export declare const credentialRefreshResponseSchema: z.ZodObject<{
             projectId: z.ZodOptional<z.ZodString>;
             email: z.ZodOptional<z.ZodString>;
             accountId: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationName: z.ZodOptional<z.ZodString>;
             mcpBinding: z.ZodOptional<z.ZodObject<{
                 resourceOrigin: z.ZodString;
                 tokenEndpoint: z.ZodString;
@@ -484,6 +508,8 @@ export declare const credentialUploadRequestSchema: z.ZodObject<{
         projectId: z.ZodOptional<z.ZodString>;
         email: z.ZodOptional<z.ZodString>;
         accountId: z.ZodOptional<z.ZodString>;
+        organizationId: z.ZodOptional<z.ZodString>;
+        organizationName: z.ZodOptional<z.ZodString>;
         mcpBinding: z.ZodOptional<z.ZodObject<{
             resourceOrigin: z.ZodString;
             tokenEndpoint: z.ZodString;
@@ -505,6 +531,8 @@ export declare const credentialUploadResponseSchema: z.ZodObject<{
             projectId: z.ZodOptional<z.ZodString>;
             email: z.ZodOptional<z.ZodString>;
             accountId: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationName: z.ZodOptional<z.ZodString>;
             mcpBinding: z.ZodOptional<z.ZodObject<{
                 resourceOrigin: z.ZodString;
                 tokenEndpoint: z.ZodString;
@@ -541,6 +569,8 @@ export declare const credentialIfAbsentUploadResponseSchema: z.ZodObject<{
             projectId: z.ZodOptional<z.ZodString>;
             email: z.ZodOptional<z.ZodString>;
             accountId: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationName: z.ZodOptional<z.ZodString>;
             mcpBinding: z.ZodOptional<z.ZodObject<{
                 resourceOrigin: z.ZodString;
                 tokenEndpoint: z.ZodString;

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

@@ -91,6 +91,8 @@ export interface CredentialInventoryRecord {
     accountId?: string;
     email?: string;
     projectId?: string;
+    organizationId?: string;
+    organizationName?: string;
     disabled: boolean;
     disabledCause: string | null;
 }
@@ -466,6 +468,25 @@ export interface CredentialDisabledEvent {
  * thrashes accounts mid-session / cold-starts the server-side prompt cache.
  */
 export type CredentialRankingMode = "balanced" | "earliest-reset";
+/**
+ * One entry of a provider's ordered, persisted soft preference list.
+ *
+ * Entries are consulted in list order when a credential is selected. Usable
+ * entries under their cap are tried first, in list order; the remaining
+ * credentials follow in the normal ranking order. An entry whose most-used
+ * known usage window has reached `maxUsedFraction` is demoted behind every
+ * other credential, so it is used only when nothing else is available. A
+ * blocked or missing entry is skipped. Unknown usage never counts as over the
+ * cap.
+ *
+ * Runtime selectors (`--credential`, `--prefer-credential`) and session
+ * stickiness take precedence over configured preferences.
+ */
+export interface ConfiguredCredentialPreference {
+    selector: AuthCredentialSelector;
+    /** Used fraction in (0, 1] at which this entry stops being preferred. Absent means only blocking moves past it. */
+    maxUsedFraction?: number;
+}
 /**
  * Whether credential selection may probe provider usage endpoints.
  *
@@ -481,6 +502,8 @@ export type AuthStorageOptions = {
     usageProviderResolver?: (provider: Provider) => UsageProvider | undefined;
     rankingStrategyResolver?: (provider: Provider) => CredentialRankingStrategy | undefined;
     credentialRankingMode?: CredentialRankingMode;
+    /** Persisted ordered soft preferences keyed by provider id. */
+    credentialPreferences?: Readonly<Record<string, readonly ConfiguredCredentialPreference[]>>;
     usageFetch?: typeof fetch;
     usageRequestTimeoutMs?: number;
     usageLogger?: UsageLogger;
@@ -548,11 +571,29 @@ export type AuthApiKeyOptions = {
     /** Prefer one stored OAuth credential while preserving quota-triggered fallback. */
     preferredCredentialSelector?: AuthCredentialSelector;
 };
-export type AuthCredentialSelectorKind = "id" | "email" | "account" | "project";
+export type AuthCredentialSelectorKind = "id" | "email" | "account" | "project" | "org";
 export interface AuthCredentialSelector {
     kind: AuthCredentialSelectorKind;
     value: string;
 }
+/**
+ * Whether an OAuth credential belongs to the organization named by an `org:`
+ * selector value: the organization id, or its display name (case-insensitive).
+ */
+export declare function oauthCredentialMatchesOrganization(credential: Pick<OAuthCredentials, "organizationId" | "organizationName">, value: string): boolean;
+/**
+ * The items an `org:` selector designates. An exact organization-id match wins
+ * over display-name matches, because names are not unique: two organizations
+ * can share a name, and a name can equal another organization's id. Callers
+ * must treat more than one result as ambiguous rather than picking one.
+ */
+export declare function selectOrganizationMatches<T>(items: readonly T[], value: string, organizationOf: (item: T) => Pick<OAuthCredentials, "organizationId" | "organizationName"> | undefined): T[];
+/**
+ * Human-facing identity of a stored OAuth credential. The organization name is
+ * appended because one account (same email) can hold one credential per
+ * organization.
+ */
+export declare function formatOAuthIdentityLabel(credential: Pick<OAuthCredentials, "email" | "accountId" | "projectId" | "organizationName">): string | null;
 /**
  * Refreshed OAuth access plus identity metadata returned by
  * {@link AuthStorage.getOAuthAccess}. Callers that authenticate via a bearer
@@ -607,7 +648,13 @@ export declare class AuthStorage {
     allocateMonotonicSequence(key: string, expiresAtSec: number): number;
     getProviderConfigurationGeneration(provider: string, owner?: object): number;
     getProviderOAuthRefreshGeneration(provider: string): number;
-    getProviderEvidenceGeneration(provider: string, resolvedApiKey?: string, owner?: object): string;
+    /**
+     * Return provider-specific discovery evidence. `stagedConfigApiKey` lets a read-only
+     * config candidate derive the same fingerprint before its owner-scoped override is published.
+     */
+    getProviderEvidenceGeneration(provider: string, resolvedApiKey?: string, owner?: object, stagedConfigApiKey?: {
+        apiKey: string;
+    }): string;
     onGenerationChanged(listener: (generation: number) => void): () => void;
     offGenerationChanged(listener: (generation: number) => void): void;
     /**
@@ -725,6 +772,8 @@ export declare class AuthStorage {
     hasRuntimeCredentialSelector(provider: string): boolean;
     /** Whether the effective selector for a session scope is pinned. */
     hasEffectiveCredentialSelector(provider: string, sessionId?: string): boolean;
+    /** Whether any runtime/session scope has a credential pin, including an unavailable hard pin. */
+    hasAnyCredentialPin(provider: string): boolean;
     /**
      * Opaque stored row id of the credential this session is currently using.
      *
@@ -738,6 +787,21 @@ export declare class AuthStorage {
      * resolver rather than a stored row.
      */
     getSessionCredentialRowId(provider: string, sessionId?: string): number | undefined;
+    /** Return the stored OAuth row pinned by a credential selector without resolving tokens. */
+    getSelectedOAuthCredentialRowId(provider: string, sessionId?: string, options?: Pick<AuthApiKeyOptions, "owner">): number | undefined;
+    /** Return the usable OAuth row selected by a soft preferred-credential selector. */
+    getPreferredOAuthCredentialRowId(provider: string): number | undefined;
+    /** Return the stored API-key row pinned by a credential selector without resolving values. */
+    getSelectedApiKeyCredentialRowId(provider: string, sessionId?: string, options?: Pick<AuthApiKeyOptions, "owner">): number | undefined;
+    /**
+     * Preview the stored API-key row request dispatch would try for this session.
+     * Requires a session id so the deterministic session order is used instead
+     * of advancing the provider's round-robin cursor. Does not resolve key values
+     * or mutate session selection.
+     */
+    getProspectiveApiKeyCredentialRowId(provider: string, sessionId: string | undefined, options?: Pick<AuthApiKeyOptions, "owner">): number | undefined;
+    /** Cached usability of a stored API key; never resolves command-backed values. */
+    getStoredApiKeyUsability(provider: string, rowId: number): boolean | undefined;
     /** Whether an enabled stored row is currently available outside quota backoff. */
     isCredentialAvailable(provider: string, rowId: number): boolean;
     /**
@@ -830,6 +894,14 @@ export declare class AuthStorage {
     acquireCredentialDispatchTicket(provider: Provider, signal?: AbortSignal): Promise<CredentialDispatchTicket | undefined>;
     /** Returns the credential type selected for a provider/session, if one has been recorded. */
     getSessionCredentialType(provider: string, sessionId?: string): AuthCredential["type"] | undefined;
+    /**
+     * Providers whose configured preference list names one stored credential row through more than one entry, for
+     * example `email:` and `account:` selectors for the same login. Startup rejects such a list.
+     */
+    findDuplicateCredentialPreferences(): Array<{
+        provider: string;
+        credentialId: number;
+    }>;
     /**
      * Get credential for a provider (first entry if multiple).
      */
@@ -858,11 +930,11 @@ export declare class AuthStorage {
      * Mirrors getApiKey selector validation, overrides, session OAuth stickiness,
      * cached command-key usability, OAuth retry, and environment fallback order.
      */
-    getEffectiveCredentialType(provider: string, sessionId?: string, options?: Pick<AuthApiKeyOptions, "owner">): AuthCredential["type"] | undefined;
-    /**
-     * Check whether configured auth is currently usable without resolving credentials.
-     */
-    hasUsableAuth(provider: string, options?: Pick<AuthApiKeyOptions, "owner">): boolean;
+    getEffectiveCredentialType(provider: string, sessionId?: string, options?: Pick<AuthApiKeyOptions, "owner" | "credentialSelector">): AuthCredential["type"] | undefined;
+    /** Check whether configured auth is usable without resolving credentials or refreshing OAuth. */
+    hasUsableAuth(provider: string, options?: Pick<AuthApiKeyOptions, "owner" | "credentialSelector"> & {
+        sessionId?: string;
+    }): boolean;
     /**
      * Check if OAuth credentials are configured for a provider.
      */
@@ -983,7 +1055,7 @@ export declare class AuthStorage {
      * and get a best-effort token. For GitHub Copilot we preserve enterprise
      * routing metadata so discovery can hit the correct host.
      */
-    peekApiKey(provider: string, options?: Pick<AuthApiKeyOptions, "owner"> & {
+    peekApiKey(provider: string, options?: AuthApiKeyOptions & {
         sessionId?: string;
     }): Promise<string | undefined>;
     /**

package/dist/types/bedrock-claude-cache-policy.d.ts

@@ -10,7 +10,7 @@ export type BedrockClaudeGeneration = {
  *  - family-first (3.x era): anthropic.claude-3-5-haiku-20241022-v1:0
  *  - kind-first (4+ era):    anthropic.claude-opus-4-20250514-v1:0,
  *                            anthropic.claude-haiku-4-5-20251001-v1:0
- * Cross-region profiles (us./eu./au./jp./apac./global. prefixes) and inference-profile
+ * Cross-region profiles (us./eu./au./jp./apac./global./in. prefixes) and inference-profile
  * ARNs keep the canonical model id as their final path segment.
  */
 export declare function parseBedrockClaudeGeneration(id: string): BedrockClaudeGeneration | undefined;

package/dist/types/model-cache.d.ts

@@ -14,11 +14,13 @@ interface CacheEntry<TApi extends Api = Api> {
     /** IDs returned by the authoritative dynamic provider catalog, when retained. */
     dynamicModelIds: string[] | undefined;
     dynamicModelProvenance: string | undefined;
+    /** User-Agent used during discovery; invalidates cache if it changes. */
+    discoveryUserAgent: string | undefined;
 }
 /** Close the shared cache only when it owns the exact requested database path. */
 export declare function closeModelCache(dbPath?: string): boolean;
-export declare function readModelCache<TApi extends Api>(providerId: string, ttlMs: number, now: () => number, dbPath?: string): CacheEntry<TApi> | null;
-export declare function writeModelCache<TApi extends Api>(providerId: string, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string, dynamicModelIds?: readonly string[], dynamicModelProvenance?: string): void;
-export declare function insertModelCacheIfAbsent<TApi extends Api>(providerId: string, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string, dynamicModelIds?: readonly string[], dynamicModelProvenance?: string): boolean;
-export declare function updateModelCacheIfUnchanged<TApi extends Api>(providerId: string, expectedUpdatedAt: number, expectedDynamicModelIds: readonly string[] | undefined, expectedDynamicModelProvenance: string | undefined, expectedModels: readonly Model<TApi>[], updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string, dynamicModelIds?: readonly string[], dynamicModelProvenance?: string): boolean;
+export declare function readModelCache<TApi extends Api>(providerId: string, ttlMs: number, now: () => number, dbPath?: string, expectedDiscoveryUserAgent?: string): CacheEntry<TApi> | null;
+export declare function writeModelCache<TApi extends Api>(providerId: string, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string, dynamicModelIds?: readonly string[], dynamicModelProvenance?: string, discoveryUserAgent?: string): void;
+export declare function insertModelCacheIfAbsent<TApi extends Api>(providerId: string, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string, dynamicModelIds?: readonly string[], dynamicModelProvenance?: string, discoveryUserAgent?: string): boolean;
+export declare function updateModelCacheIfUnchanged<TApi extends Api>(providerId: string, expectedUpdatedAt: number, expectedDynamicModelIds: readonly string[] | undefined, expectedDynamicModelProvenance: string | undefined, expectedModels: readonly Model<TApi>[], expectedDiscoveryUserAgent: string | undefined, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string, dynamicModelIds?: readonly string[], dynamicModelProvenance?: string, discoveryUserAgent?: string): boolean;
 export {};

package/dist/types/model-manager.d.ts

@@ -34,6 +34,8 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
     canPublishCache?: () => boolean;
     /** Credential-and-endpoint identity required to reuse dynamic catalog IDs. */
     cacheDynamicModelProvenance?: string;
+    /** Discovery User-Agent (e.g., for Antigravity): cache invalidates on change. */
+    discoveryUserAgent?: string;
 }
 /**
  * Resolution result.

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

@@ -27,13 +27,14 @@ export declare function isDirectXaiReasoningEffortModel(model: {
     api?: string;
     baseUrl?: string;
 }, resolvedBaseUrl?: string): boolean;
-export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "reservedToolNames">> & {
+export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "supportsUltrafastTier" | "reservedToolNames">> & {
     openRouterRouting?: OpenAICompat["openRouterRouting"];
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
     extraBody?: OpenAICompat["extraBody"];
     toolStrictMode: ResolvedToolStrictMode;
     supportsResponsesSessionAffinity?: OpenAICompat["supportsResponsesSessionAffinity"];
     supportsServiceTier?: OpenAICompat["supportsServiceTier"];
+    supportsUltrafastTier?: OpenAICompat["supportsUltrafastTier"];
     /** Optional explicit capability override; resolved via deriveToolChoiceSupport. */
     toolChoiceSupport?: OpenAICompat["toolChoiceSupport"];
 };

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

@@ -51,6 +51,16 @@ export declare function isAnthropicThinkingBlockMutationError(error: unknown): b
  * than only the latest one.
  */
 export declare function isAnthropicThinkingSignatureInvalidError(error: unknown): boolean;
+/**
+ * 400 shape where Anthropic cannot decode one of the request's images:
+ * `{"type":"invalid_request_error","message":"Could not process image"}`.
+ * Observed for a truncated JPEG (no end-of-image marker) that local resizing
+ * also failed to decode and therefore forwarded unchanged. The body names no
+ * image, and the image stays in history, so without omission every later
+ * request of the session draws the same rejection.
+ */
+export declare function isAnthropicImageUnprocessableError(error: unknown): boolean;
+export declare const ANTHROPIC_OMITTED_IMAGE_PLACEHOLDER = "[Image omitted: Anthropic could not process this image. The file may be corrupt or truncated; re-export or convert it before attaching it again.]";
 /**
  * CLIProxyAPI replaces Anthropic's rejection body wholesale instead of forwarding
  * it: the client only ever sees

package/dist/types/providers/aws-credential-config.d.ts

@@ -1,3 +1,4 @@
+import type { FetchImpl } from "../types";
 import type { AwsCredentials } from "./aws-sigv4";
 export type AwsIniFile = Record<string, Record<string, string>>;
 export interface AwsCredentialSourceOptions {
@@ -16,4 +17,8 @@ export declare function classifyAwsProfileCapability(profile: string, credential
 export declare function hasResolvableAwsProfileSource(options?: AwsCredentialSourceOptions & {
     onScan?: () => void;
 }, now?: number): boolean;
+/** Probe only the IMDSv2 token and role endpoints; never request role credentials for status. */
+export declare function hasAwsInstanceProfileCredentialSource(options?: {
+    fetch?: FetchImpl;
+}): Promise<boolean>;
 export declare function isValidBedrockBearerToken(token: string | undefined): token is string;

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

@@ -14,8 +14,15 @@
  * (default 60s). Concurrent callers waiting on a refresh share the same in-flight promise.
  */
 import type { FetchImpl } from "../types";
+export type VertexCredentialSource = "explicit-file" | "default-file" | "metadata-server";
+/** Match the region-label constraint used before Vertex interpolates a location into the request host. */
+export declare function isValidVertexLocation(location: string): boolean;
 /** Test seam: the ADC credentials file path as resolved from trusted env. */
 export declare function resolveAdcCredentialsPathForTest(): string | undefined;
+/** Resolve the source of a currently usable ADC credential without acquiring an access token. */
+export declare function getVertexCredentialSource(options?: {
+    fetch?: FetchImpl;
+}): Promise<VertexCredentialSource | undefined>;
 /**
  * Returns a Bearer access token suitable for the `Authorization` header on Vertex AI calls.
  * The token is cached in module scope and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` ms before it expires.

package/dist/types/providers/google-gemini-headers.d.ts

@@ -29,13 +29,18 @@ export declare const ANTIGRAVITY_SYSTEM_INSTRUCTION = "You are Antigravity, a po
 /**
  * Antigravity / Cloud Code Assist user agent.
  *
- * Disassembly-confirmed: getUserAgentName() @ 0x5ecb1dd loads "antigravity-ide"
- * via LEA RDX, [RIP-0x284fc90] → 0x367b554 = "antigravity-ide"
+ * Field-evidence-based default: A/B/A test on Windows+Ultra (subscriber) confirmed that
+ * 'antigravity/cli/1.3.4 (os_type=darwin; arch=arm64; aidev_client; auth_method=oauth)'
+ * unlocks Gemini 4 Argon (low/medium/high) and Gemini 3.8 Flash (low/medium/high) models,
+ * plus Opus 5.5. Reverting to 'antigravity-ide' hides Argon models again. Pro accounts
+ * receive 'gemini-4-argon-disabled' with disabled:true, confirming the UA gates model
+ * visibility by account tier. The darwin/arm64 values were tested on Windows and worked,
+ * suggesting this is not platform-specific but rather a client identity string.
  *
- * The LS sets HTTP headers via: fmt.Sprintf("User-Agent: %s", getUserAgentName())
- * So the final header is: User-Agent: antigravity-ide
+ * Historical note: Disassembly (0x5ecb1dd) showed the IDE binary loads 'antigravity-ide';
+ * this appears to be outdated or a fallback for older clients.
  *
- * -override_user_agent flag can override this (confirmed at 0x5ecbc37).
+ * Overridable via PI_AI_ANTIGRAVITY_USER_AGENT environment variable.
  */
 export declare let getAntigravityUserAgent: () => string;
 export declare const getAntigravityRequestHeaders: () => {

package/dist/types/providers/kiro-api-key.d.ts

@@ -38,6 +38,11 @@ type KiroStreamEvent = {
         inputTokens?: number;
         outputTokens?: number;
     };
+} | {
+    type: "completion";
+    data: {
+        stopReason: "COMPLETED" | "TOOL_USE";
+    };
 } | {
     type: "refusal";
     data: {

package/dist/types/providers/openai-chat-server-schema.d.ts

@@ -1707,7 +1707,8 @@ export declare const openaiChatRequestSchema: z.ZodObject<{
         flex: "flex";
         priority: "priority";
         scale: "scale";
-    }>>>, z.ZodTransform<NonNullable<"auto" | "default" | "flex" | "priority" | "scale"> | undefined, "auto" | "default" | "flex" | "priority" | "scale" | null | undefined>>;
+        ultrafast: "ultrafast";
+    }>>>, z.ZodTransform<NonNullable<"auto" | "default" | "flex" | "priority" | "scale" | "ultrafast"> | undefined, "auto" | "default" | "flex" | "priority" | "scale" | "ultrafast" | null | undefined>>;
     metadata: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<Record<string, unknown> | undefined, Record<string, unknown> | null | undefined>>;
     logprobs: z.ZodOptional<z.ZodUnknown>;
     top_logprobs: z.ZodOptional<z.ZodUnknown>;

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

@@ -33,7 +33,7 @@ export interface OpenAICompletionsOptions extends StreamOptions {
     repetitionGuard?: RepetitionGuardOptions;
 }
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
-export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined): AssistantMessage["usage"];
+export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined, serviceTier?: ServiceTier): AssistantMessage["usage"];
 export declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompat): ChatCompletionMessageParam[];
 /**
  * Detect compatibility settings from provider and baseUrl for known providers.

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

@@ -43,6 +43,7 @@ export declare function appendResponsesToolResultMessages<TApi extends Api>(mess
 export interface ProcessResponsesStreamOptions {
     onFirstToken?: () => void;
     onOutputItemDone?: (item: ResponseOutputItem) => void;
+    serviceTier?: ServiceTier;
 }
 export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<boolean>;
 /**
@@ -99,7 +100,7 @@ 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`.
  */
-export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, provider: string, supportsServiceTier?: boolean): void;
+export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, provider: string, supportsServiceTier?: boolean, modelSupportsUltrafastTier?: boolean): void;
 type ReasoningOptions = {
     reasoning?: string;
     reasoningSummary?: "auto" | "detailed" | "concise" | null;

package/dist/types/stream.d.ts

@@ -1,7 +1,19 @@
 import type { Effort } from "./model-thinking";
 import type { AnthropicOptions } from "./providers/anthropic";
-import type { Api, AssistantMessage, Context, Model, OptionsForApi, SimpleStreamOptions, ToolChoice } from "./types";
+import type { Api, AssistantMessage, Context, FetchImpl, Model, OptionsForApi, SimpleStreamOptions, ToolChoice } from "./types";
 import { AssistantMessageEventStream } from "./utils/event-stream";
+export type EnvApiKeyCredentialSource = {
+    kind: "environment";
+    name: string;
+} | {
+    kind: "google-adc";
+    source: "explicit-file" | "default-file" | "metadata-server";
+} | {
+    kind: "aws";
+    source: "bearer-token" | "environment-credentials" | "profile" | "instance-profile";
+} | {
+    kind: "unknown";
+};
 /**
  * Get API key for provider from known environment variables, e.g. OPENAI_API_KEY.
  *
@@ -9,6 +21,26 @@ import { AssistantMessageEventStream } from "./utils/event-stream";
  * loaded into $env for app/tool execution, but must not silently fund GJC model requests.
  */
 export declare function getEnvApiKey(provider: string): string | undefined;
+/**
+ * List configured environment variable names consulted for a provider's
+ * environment credential. Values are never returned. This intentionally uses
+ * the same credential-only environment reader as {@link getEnvApiKey}.
+ */
+export declare function getEnvApiKeyEnvNames(provider: string): string[];
+/** Describe the selected source without exposing credential values or unvalidated ADC files. */
+export declare function getEnvApiKeyCredentialSource(provider: string, options?: {
+    fetch?: FetchImpl;
+}): Promise<EnvApiKeyCredentialSource | undefined>;
+/** Enumerate usable credential candidates in provider dispatch precedence without exposing credentials. */
+export declare function getEnvApiKeyCredentialSources(provider: string, options?: {
+    fetch?: FetchImpl;
+}): Promise<EnvApiKeyCredentialSource[]>;
+/** Resolve Vertex ADC provenance, including metadata-server credentials, without acquiring a token. */
+export declare function getGoogleVertexCredentialSource(options?: {
+    fetch?: FetchImpl;
+}): Promise<EnvApiKeyCredentialSource | undefined>;
+/** Name of the environment variable whose value is selected by `getEnvApiKey`, when identifiable. */
+export declare function getEnvApiKeyEnvName(provider: string): Promise<string | undefined>;
 /**
  * Enumerate every provider that has an env-var fallback for `getEnvApiKey`.
  * Used by `gjc auth-broker migrate --include-env` to discover env-sourced keys