@gajae-code/ai 0.18.12 → 0.19.0

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## [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

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

@@ -618,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);
@@ -1028,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
@@ -1074,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/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/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;

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

@@ -117,6 +117,14 @@ export interface CpaToolAliasRestoreFailure {
  */
 export declare function parseCpaToolAliasRestoreFailure(error: unknown): CpaToolAliasRestoreFailure | undefined;
 export declare function isCpaToolAliasRestoreFailure(error: unknown): boolean;
+/**
+ * How many breakpoints we are still willing to generate after a gateway has
+ * rejected a previous attempt. `explicit` mode normally emits two (a reusable
+ * prefix anchor on the last assistant turn plus a refresh point on the current
+ * user turn), so stepping down to one still caches the prefix, and only the
+ * final step gives caching up entirely.
+ */
+type GeneratedCacheBudget = 2 | 1 | 0;
 export declare const claudeCodeEntrypoint = "sdk-cli";
 export declare const claudeToolPrefix: string;
 export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
@@ -228,6 +236,8 @@ export type AnthropicClientOptionsResult = {
     fetchOptions?: AnthropicSdkClientOptions["fetchOptions"];
 };
 export declare function resolveGlmZcodeAnthropicBaseUrl(): string;
+/** Compresses request bodies with gzip for first-party Anthropic endpoints only. */
+export declare function wrapAnthropicFetchForGzip(baseFetch: FetchImpl): FetchImpl;
 export declare function isProviderRetryableError(error: unknown, provider?: string): boolean;
 export type AnthropicUsageLike = {
     cache_creation?: {
@@ -261,6 +271,11 @@ 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;
+type AnthropicCacheParams = MessageCreateParamsStreaming & {
+    cache_control?: AnthropicCacheControl;
+};
+type AnthropicCacheMode = "automatic" | "explicit" | "none";
+export declare function applyPromptCaching(params: AnthropicCacheParams, cacheMode: AnthropicCacheMode, cacheControl?: AnthropicCacheControl, budget?: GeneratedCacheBudget): void;
 export declare function normalizeCacheControlTtlOrdering(params: MessageCreateParamsStreaming): void;
 export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean, options?: {
     repairLatestAssistantThinking?: boolean;

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

@@ -42,7 +42,7 @@ export declare const ANTIGRAVITY_SYSTEM_INSTRUCTION = "You are Antigravity, a po
  *
  * Overridable via PI_AI_ANTIGRAVITY_USER_AGENT environment variable.
  */
-export declare let getAntigravityUserAgent: () => string;
+export declare function getAntigravityUserAgent(): string;
 export declare const getAntigravityRequestHeaders: () => {
     "User-Agent": string;
 };

package/dist/types/utils/discovery/antigravity.d.ts

@@ -1,3 +1,4 @@
+import { logger } from "@gajae-code/utils";
 import type { Model } from "../../types";
 /**
  * Returns the default Antigravity discovery User-Agent.
@@ -54,7 +55,7 @@ export interface FetchAntigravityDiscoveryModelsOptions {
     token: string;
     /** Optional endpoint override. Defaults to Antigravity fallback endpoints. */
     endpoint?: string;
-    /** Deprecated and ignored for antigravity discovery parity. */
+    /** Optional Google Cloud project ID for tier-gated model discovery. */
     project?: string;
     /** Optional user agent override. */
     userAgent?: string;
@@ -68,6 +69,8 @@ export interface FetchAntigravityDiscoveryModelsOptions {
      * Default: `google-antigravity`.
      */
     targetProvider?: "google-antigravity" | "google-gemini-cli";
+    /** Optional logger for debug diagnostics. */
+    logger?: Pick<typeof logger, "debug">;
 }
 /**
  * Fetches discoverable Antigravity models and normalizes them into canonical model entries.
@@ -76,3 +79,4 @@ export interface FetchAntigravityDiscoveryModelsOptions {
  * Returns `[]` only when the endpoint responds successfully with no usable models.
  */
 export declare function fetchAntigravityDiscoveryModels(options: FetchAntigravityDiscoveryModelsOptions): Promise<Model<"google-gemini-cli">[] | null>;
+export declare function getAntigravityDiscoveryUserAgent(): string;

package/dist/types/utils/oauth/glm-zcode.d.ts

@@ -1,33 +1,3 @@
-/**
- * GLM ZCode OAuth flow (UNOFFICIAL, opt-in).
- *
- * Replicates how the ZCode desktop app turns a Z.AI login into usable GLM model
- * access. This is NOT an official Z.AI OAuth client: it reuses ZCode's authorize
- * page, broker, and a custom-protocol redirect. It may break at any time and may
- * violate ZCode/Z.AI Terms of Service. Endpoints/client id are overridable via
- * `ZCODE_OAUTH_*` environment variables.
- *
- * Verified end-to-end against the ZCode host bundle (`resolveZaiApiKey` /
- * `resolveBizApiKey`) and live traffic:
- *   1. Authorize: GET {authorize}?redirect_uri=zcode://oauth/callback&response_type=code&client_id=...&state=...
- *      (custom-protocol redirect → a CLI cannot catch it, so the user pastes the code/redirect URL)
- *   2. Broker:    POST {broker} { provider:"zai", code, redirect_uri, state }
- *                  → { data: { token: <ZCode JWT>, zai: { access_token: <upstream Z.AI token> } } }
- *   3. Business:  POST {z/login} { token: <upstream Z.AI token> } → { data: { access_token: <business token> } }
- *   4. Provision: with the business token, GET getCustomerInfo → default org/project,
- *      GET/POST .../api_keys (find/create a key named "zcode-api-key"),
- *      GET .../api_keys/copy/{id} → secretKey ⇒ a real Z.AI API key "{id}.{secret}".
- *
- * Credential mapping:
- *   - `access`  = the provisioned **Z.AI API key** ("{id}.{secret}"). Model requests go to
- *                 `https://api.z.ai/api/anthropic/v1/messages` with `Authorization: Bearer <key>`
- *                 (exactly like a dashboard key) — NO zcode.z.ai gateway, NO captcha.
- *   - `refresh` = the upstream Z.AI OAuth access token (used to re-provision the key).
- * The API key is long-lived, so `expires` is set far in the future.
- *
- * This provider must NEVER force `isOAuth=true`: the key is a plain Z.AI API key, and
- * api.z.ai is not api.anthropic.com, so the Anthropic path already emits a plain bearer.
- */
 import { OAuthCallbackFlow } from "./callback-server";
 import type { OAuthController, OAuthCredentials } from "./types";
 export declare const GLM_ZCODE_REFRESH_SKEW_MS: number;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.18.12",
+	"version": "0.19.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -41,8 +41,8 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/natives": "0.18.12",
-		"@gajae-code/utils": "0.18.12",
+		"@gajae-code/natives": "0.19.0",
+		"@gajae-code/utils": "0.19.0",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"