@gajae-code/ai 0.15.4 → 0.15.5

package/CHANGELOG.md

@@ -2,13 +2,24 @@
 
 ## [Unreleased]
 
+## [0.15.5] - 2026-08-29
+
+### Added
+
+- The built-in `kiro` provider now accepts long-lived `KIRO_API_KEY` values (`ksk_…` from [app.kiro.dev](https://app.kiro.dev/settings/api-keys)) in addition to AWS Builder ID OAuth. API-key auth talks to the Kiro service root with `tokentype: API_KEY` and discovers the live model catalog via `ListAvailableModels`. Builder ID login (`gjc auth-broker login kiro` / `AWS_BEARER_TOKEN_KIRO`) is unchanged.
+
+### Fixed
+
+- The generic OpenAI Responses transport now preserves the typed `server_is_overloaded` code from an HTTP 200 terminal envelope as transport facts (`openaiErrorCode` / `providerCode`), and that statusless code classifies as a `server` fallback trigger. Both terminal shapes that carry the structured failure are covered: `response.failed`, and `response.completed` whose response `status` is `failed` (including the nested `status_details.error` form). Previously the envelope became a plain `Error`, so the only structured evidence of a capacity rejection was lost and consumers had to read provider prose. The code is matched case-sensitively and exactly, so near misses (`server_is_overloaded_now`), case variants (`SERVER_IS_OVERLOADED`), padded variants, and a `cancelled` response carrying the same code all stay untyped and unclassified; the displayed error message is unchanged in every case. The shared Azure Responses path inherits the same parsing. (#5018)
+- Kiro credential selection now rejects control-character injection and keeps non-`ksk_` values on the Builder ID bearer path. API-key failures redact the credential before reaching assistant error output, and the transport accepts provider header overrides without changing the documented endpoint contract.
+- API-key model discovery also retains the contributor-supplied static catalog for offline print-mode resolution, while live `ListAvailableModels` results remain authoritative when available.
 ## [0.15.4] - 2026-08-29
 
 ## [0.15.3] - 2026-08-27
 
 ### Fixed
 
-- Valid JSON `\uXXXX` tool arguments now execute as their canonical decoded strings instead of entering the escaped-non-ASCII resample loop. Provider adapters retain guard metadata only for malformed JSON, duplicate/deep evidence, and unpaired UTF-16 surrogates, so those cases remain fail-closed while standard escaped Hangul, emoji surrogate pairs, and printable ASCII no longer consume retries or terminate managed runs.
+- Valid JSON `\uXXXX` tool arguments now execute as their canonical decoded strings instead of entering the escaped-non-ASCII resample loop. This intentionally treats every syntactically valid decoded scalar as canonical; runtime validation cannot infer whether a valid hex digit differed from the model's intent. Provider adapters retain guard metadata for malformed escape-bearing JSON, duplicate/deep suspicious escape evidence, and unpaired UTF-16 surrogates, while standard escaped Hangul, emoji surrogate pairs, and printable ASCII no longer consume retries or terminate managed runs.
 - Explicit positive `maxTokens` values declared for custom `models.yml` models
   and model overrides now reach the provider request across the shared stream
   mapping (`max_tokens`, `max_completion_tokens`, and `max_output_tokens`).

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

@@ -682,8 +682,17 @@ export declare class AuthStorage {
      *
      * Lower priority than {@link setRuntimeApiKey} so a CLI `--api-key`
      * still wins for the duration of a single invocation.
+     *
+     * `options.envSourced` marks the value as resolved from a models.yml
+     * `apiKeyEnv` indirection. Unlike a literal pin, an env pointer only says
+     * where to look for a key; when the user has since run `auth login`, the
+     * stored api_key credential is the fresher, actively-managed secret and
+     * wins over the indirection (stored OAuth credentials still yield, so a
+     * custom-endpoint bearer is never replaced by an upstream OAuth token).
      */
-    setConfigApiKey(provider: string, apiKey: string): void;
+    setConfigApiKey(provider: string, apiKey: string, options?: {
+        envSourced?: boolean;
+    }): void;
     /**
      * Remove a single config-sourced API key override.
      */
@@ -840,13 +849,16 @@ export declare class AuthStorage {
      * Get API key for a provider.
      * Priority:
      * 1. Runtime override (CLI --api-key)
-     * 2. Config override (models.yml `providers.<name>.apiKey`)
-     * 3. Session-selected OAuth credential, when present
-     * 4. Usable or unresolved API key from storage
-     * 5. OAuth token from storage (auto-refreshed)
-     * 6. Previously unusable command-backed API key retry
-     * 7. Environment variable
-     * 8. Fallback resolver (models.yml custom providers, last-resort)
+     * 2. Config override (models.yml `providers.<name>.apiKey` literal pin)
+     * 3. Stored api_key credential from `auth login`, when the config override
+     *    is only an `apiKeyEnv` indirection
+     * 4. Config override sourced from models.yml `providers.<name>.apiKeyEnv`
+     * 5. Session-selected OAuth credential, when present
+     * 6. Usable or unresolved API key from storage
+     * 7. OAuth token from storage (auto-refreshed)
+     * 8. Previously unusable command-backed API key retry
+     * 9. Environment variable
+     * 10. Fallback resolver (models.yml custom providers, last-resort)
      */
     getApiKey(provider: string, sessionId?: string, options?: AuthApiKeyOptions): Promise<string | undefined>;
     /**
@@ -915,7 +927,9 @@ export declare class AuthStorage {
      *
      * Surfaces four layers, highest precedence first:
      *   1. Runtime override (`--api-key`).
-     *   2. Config override (`models.yml` `providers.<name>.apiKey`).
+     *   2. Config override (`models.yml` `providers.<name>.apiKey` literal pin,
+     *      or an `apiKeyEnv` indirection when no stored api_key credential
+     *      outranks it).
      *   3. Stored credential (the one this session is currently sticky to, or the
      *      one round-robin would pick next when no session id is supplied).
      *   4. Env var / fallback resolver — when no stored credential exists.

package/dist/types/provider-models/special.d.ts

@@ -24,5 +24,6 @@ export interface JetBrainsJunieModelManagerConfig {
 }
 export declare function jetbrainsJunieModelManagerOptions(_config?: JetBrainsJunieModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
 export interface KiroModelManagerConfig {
+    apiKey?: string;
 }
-export declare function kiroModelManagerOptions(_config?: KiroModelManagerConfig): ModelManagerOptions<"kiro-codewhisperer-stream">;
+export declare function kiroModelManagerOptions(config?: KiroModelManagerConfig): ModelManagerOptions<"kiro-codewhisperer-stream">;

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

@@ -0,0 +1,50 @@
+import type { Model, StreamFunction } from "../types";
+export declare function isKiroApiKey(value: string | undefined): value is string;
+export declare function kiroApiRegion(options?: {
+    region?: string;
+}): string;
+export declare function kiroApiBaseUrl(region: string): string;
+export declare function toKiroModelId(modelId: string): string;
+export declare function kiroApiStaticModels(): Model<"kiro-codewhisperer-stream">[];
+/** Discover models this API key can use. Returns null when the key is missing. */
+export declare function fetchKiroApiModels(apiKey: string, region?: string): Promise<Model<"kiro-codewhisperer-stream">[]>;
+type KiroStreamEvent = {
+    type: "content";
+    data: string;
+} | {
+    type: "toolUse";
+    data: {
+        name: string;
+        toolUseId: string;
+        input: string;
+        stop?: boolean;
+    };
+} | {
+    type: "toolUseInput";
+    data: {
+        input: string;
+    };
+} | {
+    type: "toolUseStop";
+    data: {
+        stop: boolean;
+    };
+} | {
+    type: "usage";
+    data: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+} | {
+    type: "error";
+    data: {
+        error: string;
+        message?: string;
+    };
+};
+export declare function parseKiroApiEvents(buffer: string): {
+    events: KiroStreamEvent[];
+    remaining: string;
+};
+export declare const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream">;
+export {};

package/dist/types/providers/kiro-codewhisperer.d.ts

@@ -1,5 +1,8 @@
+import type { Effort } from "../model-thinking";
 import type { StreamFunction, StreamOptions } from "../types";
 export interface KiroCodeWhispererOptions extends StreamOptions {
+    /** Effort level for Kiro API-key reasoning. */
+    reasoning?: Effort | boolean;
     /** AWS region for the CodeWhisperer streaming endpoint. */
     region?: string;
     /** Profile ARN for enterprise IAM Identity Center accounts. */

package/dist/types/types.d.ts

@@ -399,31 +399,22 @@ export interface ToolCall {
      */
     incompleteArgumentsReason?: "truncated" | "malformed" | "conflicting" | "ambiguous";
     /**
-     * Set when the raw argument JSON spelled a printable character as a `\uXXXX`
-     * escape instead of a literal character. This includes ASCII landings because
-     * a one-nibble mutation can move an intended non-ASCII scalar below U+0080.
-     * Such a payload parses cleanly but
-     * is unverifiable: one mistyped hex digit decodes to a different, equally
-     * valid character, so the text can be silently wrong with no in-band evidence.
-     * The agent loop resamples the turn a bounded number of times and then
-     * rejects the call instead of executing it. The single bounded exception
-     * is a tool that enumerated its display-only fields
-     * (`displaySafeEscapedArgFields`): when every escaped scalar corroborates
-     * a decoded non-ASCII character inside those fields, the call executes
-     * with a warning instead — rendered question text, never executable
-     * content, ids, or durable metadata.
-     * Escapes that are required (control characters) or unavoidable (lone
-     * surrogates) never set this.
+     * Set by current producers when raw argument JSON carries unsafe Unicode
+     * data, such as malformed escape evidence or a decoded unpaired surrogate.
+     * Valid JSON `\uXXXX` escapes are canonical spellings of the decoded string
+     * and current producers do not set this flag for them.
+     *
+     * Legacy producers may still set the flag for any escaped non-ASCII spelling.
+     * The agent loop keeps its bounded legacy resample/display-safe behavior for
+     * those calls while consuming the transient evidence below.
      */
     escapedNonAsciiArguments?: boolean;
     /**
-     * Bounded, payload-free evidence for the original raw escape positions and
-     * process-keyed scalar/path identities. Required for the display-safe terminal exemption: decoded values
-     * alone cannot prove that an ASCII landing such as `\u0077` was not a
-     * one-nibble mutation of a non-ASCII escape. Presence of this evidence implies
-     * the guarded state even if a legacy producer omitted
-     * `escapedNonAsciiArguments`. The agent consumes and removes this transient
-     * field before the tool-call message can become durable.
+     * Bounded, payload-free evidence for raw Unicode argument data. Current
+     * producers attach it only for unsafe data; legacy producers may attach
+     * non-malformed positional evidence used by the display-safe compatibility
+     * path. The agent consumes and removes this transient field before the
+     * tool-call message can become durable.
      */
     escapedUnicodeArgumentEvidence?: UnicodeEscapeEvidence;
 }

package/dist/types/utils/fallback-transport.d.ts

@@ -23,6 +23,13 @@ export interface FallbackTrigger {
 export declare const STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE = "stream_first_event_timeout";
 /** Stable code for a nominally successful response with no content or token usage. */
 export declare const EMPTY_RESPONSE_PROVIDER_CODE = "empty_response";
+/**
+ * OpenAI's typed capacity-overload code. It arrives without an HTTP status —
+ * inside an HTTP 200 terminal Responses envelope or a Codex error event — so the
+ * code itself is the only structured evidence of the failure and must survive
+ * the existence gate below. It is always compared case-sensitively.
+ */
+export declare const SERVER_OVERLOADED_PROVIDER_CODE = "server_is_overloaded";
 export type TransportHeaders = Headers | Record<string, string | undefined>;
 /**
  * Structured facts from an upstream HTTP or transport failure. Retry decisions

package/dist/types/utils/json-parse.d.ts

@@ -67,9 +67,11 @@ export declare function collectUnicodeEscapeEvidence(json: string): UnicodeEscap
 /**
  * Return evidence only when decoded tool arguments are unsafe to execute.
  *
- * Valid JSON escapes and literal UTF-8 have the same canonical decoded value.
- * Malformed JSON, duplicate/deep evidence, and unpaired UTF-16 surrogates keep
- * the existing fail-closed path.
+ * Valid JSON escapes and literal UTF-8 have the same canonical decoded value,
+ * including a valid scalar whose hex digits differ from what a caller intended:
+ * runtime syntax validation cannot infer author intent after decoding.
+ * Malformed escape-bearing JSON, duplicate/deep suspicious escape evidence, and
+ * unpaired UTF-16 surrogates keep the fail-closed path.
  */
 export declare function collectUnsafeUnicodeEscapeEvidence(json: string): UnicodeEscapeEvidence | undefined;
 /** Attach unsafe raw evidence while preserving the existing call-level guard flag. */

package/dist/types/utils/tool-call-healing.d.ts

@@ -22,10 +22,10 @@ export interface HealedToolCall {
     readonly name: string;
     readonly arguments: string;
     /**
-     * Whether the raw leaked payload spelled a printable non-ASCII character as a
-     * `\uXXXX` escape. Captured BEFORE the normalizing round-trip below, which
-     * decodes escapes into literal characters and would otherwise erase the only
-     * evidence that the text is unverifiable.
+     * Whether the raw leaked payload carried unsafe Unicode argument data.
+     * Captured before the normalizing round-trip below, which would otherwise
+     * erase malformed escape evidence. Valid `\uXXXX` spellings decode
+     * canonically and leave this false.
      */
     readonly escapedNonAsciiArguments: boolean;
     readonly escapedUnicodeArgumentEvidence?: UnicodeEscapeEvidence;

package/package.json

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

package/src/auth-storage.ts

@@ -1231,6 +1231,14 @@ export class AuthStorage {
 	#data: Map<string, StoredCredential[]> = new Map();
 	#runtimeOverrides: Map<string, string> = new Map();
 	#configOverrides: Map<string, string> = new Map();
+	/**
+	 * Providers whose config override was resolved from a models.yml `apiKeyEnv`
+	 * indirection rather than a literal `apiKey` pin. An env pointer is not a
+	 * pinned secret: the pointed-to value (shell env, trusted env files) can go
+	 * stale silently, and the 401 rotation machinery cannot repair it. A stored
+	 * api_key credential from `auth login` therefore outranks it.
+	 */
+	#configOverrideEnvSourced: Set<string> = new Set();
 	#runtimeCredentialSelectors: Map<string, AuthCredentialSelector> = new Map();
 	/** Soft runtime credential preference per provider; quota failures may rotate away from it. */
 	#runtimePreferredCredentialSelectors: Map<string, AuthCredentialSelector> = new Map();
@@ -1926,10 +1934,22 @@ export class AuthStorage {
 	 *
 	 * Lower priority than {@link setRuntimeApiKey} so a CLI `--api-key`
 	 * still wins for the duration of a single invocation.
+	 *
+	 * `options.envSourced` marks the value as resolved from a models.yml
+	 * `apiKeyEnv` indirection. Unlike a literal pin, an env pointer only says
+	 * where to look for a key; when the user has since run `auth login`, the
+	 * stored api_key credential is the fresher, actively-managed secret and
+	 * wins over the indirection (stored OAuth credentials still yield, so a
+	 * custom-endpoint bearer is never replaced by an upstream OAuth token).
 	 */
-	setConfigApiKey(provider: string, apiKey: string): void {
+	setConfigApiKey(provider: string, apiKey: string, options: { envSourced?: boolean } = {}): void {
 		const storageProvider = resolveOAuthStorageProvider(provider);
 		this.#configOverrides.set(storageProvider, apiKey);
+		if (options.envSourced) {
+			this.#configOverrideEnvSourced.add(storageProvider);
+		} else {
+			this.#configOverrideEnvSourced.delete(storageProvider);
+		}
 		this.#bumpGeneration("set-config-api-key", storageProvider);
 	}
 
@@ -1938,6 +1958,7 @@ export class AuthStorage {
 	 */
 	removeConfigApiKey(provider: string): void {
 		const storageProvider = resolveOAuthStorageProvider(provider);
+		this.#configOverrideEnvSourced.delete(storageProvider);
 		if (this.#configOverrides.delete(storageProvider)) this.#bumpGeneration("remove-config-api-key", storageProvider);
 	}
 
@@ -1947,6 +1968,7 @@ export class AuthStorage {
 	 */
 	clearConfigApiKeys(): void {
 		const providers = [...this.#configOverrides.keys()];
+		this.#configOverrideEnvSourced.clear();
 		if (providers.length === 0) return;
 		this.#configOverrides.clear();
 		for (const provider of providers) this.#bumpGeneration("clear-config-api-keys", provider);
@@ -5165,9 +5187,16 @@ export class AuthStorage {
 		if (runtimeKey) return runtimeKey;
 
 		const configKey = this.#configOverrides.get(provider);
-		if (configKey) return configKey;
+		if (configKey && !this.#configOverrideEnvSourced.has(provider)) return configKey;
 
 		const selectedCredential = this.#resolveSelectedStoredCredential(provider, undefined, undefined);
+		if (configKey) {
+			// Env-sourced (`apiKeyEnv`) override: same precedence as getApiKey —
+			// a stored api_key credential from `auth login` wins, stored OAuth
+			// still yields to the indirection.
+			const storedApiKey = await this.#resolveStoredApiKeyOverEnvConfig(provider, selectedCredential, undefined);
+			return storedApiKey ?? configKey;
+		}
 		if (selectedCredential?.credential.type === "api_key") {
 			return this.#resolveStoredApiKey(provider, selectedCredential.credential.key);
 		}
@@ -5217,13 +5246,16 @@ export class AuthStorage {
 	 * Get API key for a provider.
 	 * Priority:
 	 * 1. Runtime override (CLI --api-key)
-	 * 2. Config override (models.yml `providers.<name>.apiKey`)
-	 * 3. Session-selected OAuth credential, when present
-	 * 4. Usable or unresolved API key from storage
-	 * 5. OAuth token from storage (auto-refreshed)
-	 * 6. Previously unusable command-backed API key retry
-	 * 7. Environment variable
-	 * 8. Fallback resolver (models.yml custom providers, last-resort)
+	 * 2. Config override (models.yml `providers.<name>.apiKey` literal pin)
+	 * 3. Stored api_key credential from `auth login`, when the config override
+	 *    is only an `apiKeyEnv` indirection
+	 * 4. Config override sourced from models.yml `providers.<name>.apiKeyEnv`
+	 * 5. Session-selected OAuth credential, when present
+	 * 6. Usable or unresolved API key from storage
+	 * 7. OAuth token from storage (auto-refreshed)
+	 * 8. Previously unusable command-backed API key retry
+	 * 9. Environment variable
+	 * 10. Fallback resolver (models.yml custom providers, last-resort)
 	 */
 	async getApiKey(provider: string, sessionId?: string, options?: AuthApiKeyOptions): Promise<string | undefined> {
 		provider = resolveOAuthStorageProvider(provider);
@@ -5239,7 +5271,17 @@ export class AuthStorage {
 		// honor it instead of forwarding an upstream OAuth token that the proxy
 		// won't accept.
 		const configKey = this.#configOverrides.get(provider);
-		if (configKey) return configKey;
+		if (configKey) {
+			if (!this.#configOverrideEnvSourced.has(provider)) return configKey;
+			// The override is an `apiKeyEnv` indirection, not a pinned value. A
+			// stored api_key credential from `auth login` is actively managed
+			// (validated at login, rotated on 401), while the pointed-to env
+			// value can go stale with no recovery path — prefer the stored
+			// credential. Stored OAuth credentials still yield to the override.
+			const storedApiKey = await this.#resolveStoredApiKeyOverEnvConfig(provider, selectedCredential, sessionId);
+			if (storedApiKey) return storedApiKey;
+			return configKey;
+		}
 
 		if (selectedCredential?.credential.type === "api_key") {
 			this.#recordSessionCredential(provider, sessionId, "api_key", selectedCredential.index);
@@ -5295,6 +5337,38 @@ export class AuthStorage {
 		return this.#fallbackResolver?.(provider) ?? undefined;
 	}
 
+	/**
+	 * Resolve a stored api_key credential that outranks an env-sourced config
+	 * override (`apiKeyEnv`). Mirrors the api_key branches of {@link getApiKey}:
+	 * the selector-pinned credential first, then the round-robin/session pool.
+	 * Returns undefined when no stored api_key credential resolves, leaving the
+	 * env-sourced override in effect.
+	 */
+	async #resolveStoredApiKeyOverEnvConfig(
+		provider: string,
+		selectedCredential: ({ index: number } & StoredCredential) | undefined,
+		sessionId?: string,
+	): Promise<string | undefined> {
+		if (selectedCredential?.credential.type === "api_key") {
+			const resolved = await this.#resolveStoredApiKey(provider, selectedCredential.credential.key);
+			if (resolved) {
+				this.#recordSessionCredential(provider, sessionId, "api_key", selectedCredential.index);
+				return resolved;
+			}
+		}
+		const attemptedApiKeyIndices = new Set<number>();
+		for (;;) {
+			const apiKeySelection = this.#selectApiKeyCredential(provider, sessionId, attemptedApiKeyIndices);
+			if (!apiKeySelection) return undefined;
+			attemptedApiKeyIndices.add(apiKeySelection.index);
+			const resolved = await this.#resolveStoredApiKey(provider, apiKeySelection.credential.key);
+			if (resolved) {
+				this.#recordSessionCredential(provider, sessionId, "api_key", apiKeySelection.index);
+				return resolved;
+			}
+		}
+	}
+
 	/**
 	 * Resolve the OAuth credential for `provider`, refreshing through the same
 	 * pipeline as {@link AuthStorage.getApiKey} but returning the refreshed
@@ -5621,7 +5695,9 @@ export class AuthStorage {
 	 *
 	 * Surfaces four layers, highest precedence first:
 	 *   1. Runtime override (`--api-key`).
-	 *   2. Config override (`models.yml` `providers.<name>.apiKey`).
+	 *   2. Config override (`models.yml` `providers.<name>.apiKey` literal pin,
+	 *      or an `apiKeyEnv` indirection when no stored api_key credential
+	 *      outranks it).
 	 *   3. Stored credential (the one this session is currently sticky to, or the
 	 *      one round-robin would pick next when no session id is supplied).
 	 *   4. Env var / fallback resolver — when no stored credential exists.
@@ -5633,7 +5709,12 @@ export class AuthStorage {
 			return "runtime override (--api-key)";
 		}
 		if (this.#configOverrides.has(provider)) {
-			return "config override (models.yml)";
+			// An `apiKeyEnv` indirection loses to a stored api_key credential
+			// (see getApiKey); describe the credential that actually wins.
+			const shadowed = this.#getStoredCredentials(provider).some(entry => entry.credential.type === "api_key");
+			if (!this.#configOverrideEnvSourced.has(provider) || !shadowed) {
+				return "config override (models.yml)";
+			}
 		}
 
 		const baseLabel = this.#sourceLabel ?? "local store";

package/src/model-thinking.ts

@@ -549,6 +549,22 @@ function applyGeneratedModelPolicy(model: ApiModel<Api>): void {
 			levels: [Effort.Low, Effort.High, Effort.Max],
 		};
 	}
+	// GLM-5.3-Flash keeps GLM-5.3's text contract: 1M context, 128K output, and
+	// the same always-on low/high/max reasoning_effort. models.dev currently
+	// lists it with null limits, so pin the contract the same way.
+	// https://docs.z.ai/guides/llm/glm-5.3-flash ("Text parameters are
+	// consistent with GLM-5.3, with support for a 1M-token context window.")
+	if (model.provider === "zai" && model.id === "glm-5.3-flash") {
+		model.contextWindow = 1_000_000;
+		model.maxTokens = 131_072;
+		model.thinking = {
+			mode: "effort",
+			minLevel: Effort.Low,
+			maxLevel: Effort.Max,
+			defaultLevel: Effort.Max,
+			levels: [Effort.Low, Effort.High, Effort.Max],
+		};
+	}
 	// Groq's agentic `compound` systems reject `reasoning_effort` outright
 	// (400 "`reasoning_effort` is not supported with this model", verified
 	// 2026-08-23), yet models.dev advertises them as reasoning models. Drop the

package/src/models.json

@@ -89307,6 +89307,37 @@
 				]
 			}
 		},
+		"glm-5.3-flash": {
+			"id": "glm-5.3-flash",
+			"name": "GLM-5.3-Flash",
+			"api": "anthropic-messages",
+			"provider": "zai",
+			"baseUrl": "https://api.z.ai/api/anthropic",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 1000000,
+			"maxTokens": 131072,
+			"thinking": {
+				"mode": "effort",
+				"minLevel": "low",
+				"maxLevel": "max",
+				"defaultLevel": "max",
+				"levels": [
+					"low",
+					"high",
+					"max"
+				]
+			}
+		},
 		"glm-5v-turbo": {
 			"id": "glm-5v-turbo",
 			"name": "GLM-5V-Turbo",

package/src/models.ts

@@ -29,7 +29,15 @@ const providerModelRegistry: Map<string, Map<string, Model<Api>>> = new Map();
 function getBundledCatalog(): BundledCatalog {
 	// TS types a .json import as its contents; at runtime `with { type: "file" }`
 	// yields the file path (bunfs path in compiled binaries, disk path in dev).
-	bundledCatalog ??= JSON.parse(readFileSync(modelsJsonPath as unknown as string, "utf8")) as BundledCatalog;
+	if (bundledCatalog !== undefined) return bundledCatalog;
+	const resource = modelsJsonPath as unknown;
+	if (typeof resource === "string") {
+		bundledCatalog = JSON.parse(readFileSync(resource, "utf8")) as BundledCatalog;
+	} else if (resource !== null && typeof resource === "object") {
+		bundledCatalog = resource as BundledCatalog;
+	} else {
+		throw new Error("Bundled models catalog resource is invalid.");
+	}
 	return bundledCatalog;
 }
 

package/src/provider-models/special.ts

@@ -3,6 +3,7 @@ import { once, sanitizeText } from "@gajae-code/utils";
 
 import type { ModelManagerOptions } from "../model-manager";
 import { buildZCodeSourceHeaders, resolveGlmZcodeAnthropicBaseUrl } from "../providers/anthropic";
+import { fetchKiroApiModels, isKiroApiKey, kiroApiStaticModels } from "../providers/kiro-api-key";
 import { fetchOpenCodexModels, OPENCODEX_MODEL_CACHE_TTL_MS } from "../providers/openai-opencodex-responses";
 import { fetchCodexModels } from "../utils/discovery/codex";
 import { fetchOpenAICompatibleModels } from "../utils/discovery/openai-compatible";
@@ -164,10 +165,21 @@ export function jetbrainsJunieModelManagerOptions(
 // Kiro (Amazon Q Developer / CodeWhisperer)
 // ---------------------------------------------------------------------------
 
-export interface KiroModelManagerConfig {}
+export interface KiroModelManagerConfig {
+	apiKey?: string;
+}
 
 export function kiroModelManagerOptions(
-	_config: KiroModelManagerConfig = {},
+	config: KiroModelManagerConfig = {},
 ): ModelManagerOptions<"kiro-codewhisperer-stream"> {
-	return { providerId: "kiro" };
+	const apiKey = config.apiKey;
+	return {
+		providerId: "kiro",
+		...(isKiroApiKey(apiKey)
+			? {
+					staticModels: kiroApiStaticModels(),
+					fetchDynamicModels: () => fetchKiroApiModels(apiKey),
+				}
+			: undefined),
+	};
 }

package/src/providers/kiro-api-key.d.ts

@@ -0,0 +1,50 @@
+import type { Model, StreamFunction } from "../types";
+export declare function isKiroApiKey(value: string | undefined): value is string;
+export declare function kiroApiRegion(options?: {
+    region?: string;
+}): string;
+export declare function kiroApiBaseUrl(region: string): string;
+export declare function toKiroModelId(modelId: string): string;
+export declare function kiroApiStaticModels(): Model<"kiro-codewhisperer-stream">[];
+/** Discover models this API key can use. Returns null when the key is missing. */
+export declare function fetchKiroApiModels(apiKey: string, region?: string): Promise<Model<"kiro-codewhisperer-stream">[]>;
+type KiroStreamEvent = {
+    type: "content";
+    data: string;
+} | {
+    type: "toolUse";
+    data: {
+        name: string;
+        toolUseId: string;
+        input: string;
+        stop?: boolean;
+    };
+} | {
+    type: "toolUseInput";
+    data: {
+        input: string;
+    };
+} | {
+    type: "toolUseStop";
+    data: {
+        stop: boolean;
+    };
+} | {
+    type: "usage";
+    data: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+} | {
+    type: "error";
+    data: {
+        error: string;
+        message?: string;
+    };
+};
+export declare function parseKiroApiEvents(buffer: string): {
+    events: KiroStreamEvent[];
+    remaining: string;
+};
+export declare const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream">;
+export {};