@gajae-code/ai 0.18.11 → 0.19.0

package/CHANGELOG.md

@@ -2,6 +2,109 @@
 
 ## [Unreleased]
 
+## [0.19.0] - 2026-10-22
+
+### Added
+
+- Added the Amazon Bedrock Claude Haiku 5.5 selectors (`anthropic.claude-haiku-5-5` and the `au.`, `eu.`, `global.`, `jp.` and `us.` inference profiles) to the bundled catalog, taken from a fresh `generate-models` run.
+- Bedrock Haiku 5.5 resolves to adaptive thinking with the documented `low`..`max` effort range and `medium` default, sends an explicit `thinking: { type: "disabled" }` when thinking is Off (with a forced tool choice the selected effort is kept, capped at `high` while thinking is disabled), and bills prompts above 100K tokens at a long-context tier, with 1-hour cache writes (long retention) at twice the tier input rate.
+
+- Added Claude Haiku 5.5 (`anthropic/claude-haiku-5-5`) to the bundled catalog, taken from a fresh `generate-models` run. Bedrock selectors are not part of this change.
+- Claude Haiku 5.5 resolves to adaptive thinking with the documented `low`..`max` effort range and `medium` default on the Anthropic Messages API. Direct requests omit unsupported sampling controls, send an explicit `thinking: { type: "disabled" }` when thinking is Off, and with a forced tool choice keep the selected effort (capped at `high` while thinking is disabled), request summarized thinking output, and use the documented >100K-token pricing tier, billing 1-hour cache writes at their own rate from the response TTL split. Haiku 4.5 and older keep their existing behavior.
+
+### Changed
+
+- First-party Anthropic requests (`api.anthropic.com` over HTTPS) now send gzip-compressed bodies with `Content-Encoding: gzip`, which shrinks large, repetitive prompts substantially. Third-party endpoints, non-standard ports, and stream bodies are sent unchanged, and a stale `Content-Length` is dropped so the transport recomputes it.
+
+### Fixed
+
+- Antigravity model discovery now identifies with the Gemini CLI user agent so Gemini 4 Argon can be returned without relying on project metadata. Both `google-antigravity` and `google-gemini-cli` still forward project IDs from stored OAuth credentials or structured Google keys when available, and the generated-model refresh path forwards the stored project ID too. Discovery diagnostics redact endpoint credentials, and custom loggers keep their method receiver.
+- Google discovery cache identity now includes the session-selected project and the effective user agent for both Google providers, so catalogs are not reused across projects, CLI identities, or custom Antigravity user-agent overrides. Project-specific dynamic rows are also removed or withheld when the selected project changes.
+
+- Automatic Anthropic prompt caching now also marks the last system block, so a new session reads the shared tools + system prefix instead of re-writing it.
+
+- Anthropic automatic prompt caching no longer adds a root cache marker when caller markers already occupy all four breakpoints, which made the request fail validation.
+
+- `disableReasoning` is now honored on the Bedrock path, so budget-mode Bedrock models keep the caller's requested output cap when reasoning is disabled.
+
+- GLM ZCode OAuth endpoints and the client id (`ZCODE_OAUTH_*`) now resolve from the launching shell and user-owned env files, so a project `.env` cannot redirect the authorize, broker, or login calls. A dynamic project declaration also blocks a different shell value for that name.
+
+- A usage limit that is scoped to one model (an explicit `scope.modelId`, or a model-family tier such as Claude's `opus`/`sonnet`) no longer takes the whole credential out of rotation. The block is recorded for that model only, ranking ignores limits scoped to other models, and callers that do not know the requested model keep the previous conservative behaviour. Plan and quota tiers (`Codex`/`Copilot` plans, Gemini quota tiers) still apply to every model.
+
+- OpenAI Codex token refresh error messages now display readable error details instead of `[object Object]` when the OpenAI token endpoint returns structured error objects with `code`, `type`, and `message` fields. Both string errors (with optional `error_description`) and object errors are now handled correctly.
+
+- `getProxyForUrl` ignores `PI_PROXY`, `PI_PROXY_<PROVIDER>`, `HTTP_PROXY`, `HTTPS_PROXY`, and `ALL_PROXY` (and their lowercase aliases) when the project dotenv declares that value. The startup snapshot remains in force when `--worktree` changes cwd before the proxy module's first use. A different shell value is still used only when that declaration is a comparable static value. A dynamic or incomparable declaration (expansion, quoted inner whitespace, or an escape the snapshot will not compare) drops the shell value as well.
+
+- Orphan tool results restored as a user stale-tool-result note escape `&`, `<`, and `>` in the tool text, and attribute metacharacters in the tool name and id, so a closing tag in the tool output cannot end the note early.
+
+## [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

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
@@ -577,11 +618,6 @@ export interface InvalidateCredentialMatchingOptions {
 /** Read optional broker error detail without allowing hostile objects to escape classification. */
 /** @internal Tested directly because hostile accessors must preserve the original error identity. */
 export declare function readBrokerErrorBody(error: unknown): string | undefined;
-/**
- * Credential storage backed by an AuthCredentialStore.
- * Reads from storage on reload(), manages round-robin credential selection,
- * usage limit tracking, and OAuth token refresh.
- */
 export declare class AuthStorage {
     #private;
     constructor(store: AuthCredentialStore, options?: AuthStorageOptions);
@@ -607,7 +643,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 +767,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 +782,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 +889,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 +925,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.
      */
@@ -956,7 +1023,17 @@ export declare class AuthStorage {
         signal?: AbortSignal;
         owner?: object;
         rowId?: number;
+        /** Scope the block to one model; other models keep using the credential. */
+        modelId?: string;
     }): Promise<UsageLimitMarkResult>;
+    /**
+     * Opaque stored row IDs for credentials whose resolved key matches `apiKey`.
+     * Unlike the session's sticky row pointer, these remain tied to the actual key
+     * when concurrent requests share a credential session ID.
+     * A row that cannot be resolved is skipped so an unrelated resolver failure
+     * cannot prevent callers from using already-known credential identity.
+     */
+    getCredentialRowIdsMatchingApiKey(provider: string, apiKey: string): Promise<number[]>;
     /**
      * Mark the stored credential whose key matches `apiKey` usage-limited for
      * `retryAfterMs` (or the default backoff). Used when the caller knows
@@ -983,7 +1060,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>;
     /**
@@ -1002,6 +1079,14 @@ export declare class AuthStorage {
      * 10. Fallback resolver (models.yml custom providers, last-resort)
      */
     getApiKey(provider: string, sessionId?: string, options?: AuthApiKeyOptions): Promise<string | undefined>;
+    /**
+     * Resolve an API key and retain the selected stored row identity across token refreshes
+     * and concurrent changes to the session's sticky credential pointer.
+     */
+    getApiKeyWithCredentialRowId(provider: string, sessionId?: string, options?: AuthApiKeyOptions): Promise<{
+        apiKey: string | undefined;
+        credentialRowId: number | undefined;
+    }>;
     /**
      * Resolve the OAuth credential for `provider`, refreshing through the same
      * pipeline as {@link AuthStorage.getApiKey} but returning the refreshed

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/model-pricing.d.ts

@@ -1,3 +1,11 @@
 import type { Api, Model, ModelCost } from "./types";
 export declare function getOpenAIModelCost<TApi extends Api>(model: Model<TApi>, inputTokens: number): ModelCost | undefined;
+export declare function getAnthropicModelCost<TApi extends Api>(model: Model<TApi>, inputTokens: number): ModelCost | undefined;
+/**
+ * $/million rate for 1-hour cache writes, or undefined when the model has a single
+ * cache-write rate. Cost calculation applies it to `usage.cttl.ephemeral1h` and bills
+ * the remaining cache-write tokens at `ModelCost.cacheWrite`.
+ */
+export declare function getAnthropicCacheWriteOneHourRate<TApi extends Api>(model: Model<TApi>, inputTokens: number): number | undefined;
+export declare function applyAnthropicModelPricing<TApi extends Api>(model: Model<TApi>): void;
 export declare function applyOpenAIModelPricing<TApi extends Api>(model: Model<TApi>): void;

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

@@ -87,12 +87,23 @@ export declare function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(mod
  * - Thinking content is omitted by default (needs display: "summarized")
  */
 export declare function hasOpus47ApiRestrictions(modelId: string): boolean;
+/**
+ * Haiku 5+ enables adaptive thinking when the `thinking` field is omitted.
+ * An explicit user-facing Off choice must therefore send `type: "disabled"`.
+ */
+export declare function requiresAnthropicThinkingDisableWhenOff(modelId: string): boolean;
+/**
+ * Haiku 5+ and Opus 4.7+ reject sampling parameters on the Anthropic Messages API.
+ * https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide#remove-sampling-parameters
+ */
+export declare function hasAnthropicModelSamplingRestrictions(modelId: string): boolean;
 /**
  * Adaptive thinking `display` is supported starting with Anthropic Opus 4.7.
  * Older adaptive-thinking models (Opus 4.6, Sonnet 4.6+) reject the field.
  * Fable (5+) postdates Opus 4.7, accepts `display`, and defaults it to
  * "omitted" — thinking tokens are billed but no content streams back — so it
  * must opt in like Opus 4.7+ (issue #2791).
+ * Haiku 5+ also accepts `display` and defaults it to "omitted".
  *
  * Shares `hasOpus47ApiRestrictions` version parsing on purpose: the two
  * predicates describe the same API generation, and a private `claude-opus-(\d+)-(\d+)`

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/provider-models/google.d.ts

@@ -9,10 +9,12 @@ export interface GoogleVertexModelManagerConfig {
 export interface GoogleAntigravityModelManagerConfig {
     oauthToken?: string;
     endpoint?: string;
+    project?: string;
 }
 export interface GoogleGeminiCliModelManagerConfig {
     oauthToken?: string;
     endpoint?: string;
+    project?: string;
 }
 export declare function googleModelManagerOptions(config?: GoogleModelManagerConfig): ModelManagerOptions<"google-generative-ai">;
 export declare function googleVertexModelManagerOptions(_config?: GoogleVertexModelManagerConfig): ModelManagerOptions<"google-vertex">;

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

@@ -8,7 +8,7 @@
  */
 import { parseBedrockClaudeGeneration } from "../bedrock-claude-cache-policy";
 import type { Effort } from "../model-thinking";
-import type { Model, StreamFunction, StreamOptions, ThinkingBudgets, Tool, ToolChoice } from "../types";
+import type { AssistantMessage, CacheRetention, Model, StreamFunction, StreamOptions, ThinkingBudgets, Tool, ToolChoice } from "../types";
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 export interface BedrockOptions extends StreamOptions {
     region?: string;
@@ -51,7 +51,18 @@ interface WireToolConfig {
     tools: WireToolSpec[];
     toolChoice?: WireToolChoice;
 }
+interface MetadataEvent {
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadInputTokens?: number;
+        cacheWriteInputTokens?: number;
+        totalTokens?: number;
+    };
+}
 export declare const streamBedrock: StreamFunction<"bedrock-converse-stream">;
+/** Exported for unit tests of the usage-to-cost path. */
+export declare function handleMetadata(event: MetadataEvent, model: Model<"bedrock-converse-stream">, output: AssistantMessage, cacheRetention: CacheRetention): void;
 /**
  * Check if the model supports prompt caching.
  * Supported: Claude 3.5 Haiku, Claude 3.7 Sonnet, and every later Claude
@@ -71,5 +82,9 @@ export declare function stripBedrockForcedToolChoiceForRetry<T extends {
     toolConfig?: {
         toolChoice?: unknown;
     };
-}>(body: T): T;
+    additionalModelRequestFields?: Record<string, unknown>;
+}>(body: T, thinking?: {
+    forced: Record<string, unknown> | undefined;
+    restored: Record<string, unknown>;
+}): T;
 export declare function convertToolConfig(tools: Tool[] | undefined, toolChoice: BedrockOptions["toolChoice"]): WireToolConfig | undefined;