@gajae-code/ai 0.15.4 → 0.15.6

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

@@ -15,6 +15,11 @@ export type ApiKeyCredential = {
     type: "api_key";
     key: string;
 };
+/**
+ * Extracts the bearer token from the structured API-key form used by OAuth
+ * providers that need to carry token metadata alongside the access token.
+ */
+export declare function extractStructuredApiKeyToken(apiKey: string): string | undefined;
 export interface MCPOAuthBinding {
     /** Exact HTTP(S) origin of the MCP resource endpoint. */
     resourceOrigin: string;
@@ -203,6 +208,7 @@ export interface AuthCredentialSnapshotEntry {
     provider: string;
     credential: SnapshotCredential;
     identityKey: string | null;
+    revision?: number;
 }
 export type AuthCredentialIfAbsentReason = "inserted" | "updated-existing" | "skipped-existing" | "skipped-existing-runtime" | "skipped-existing-config" | "skipped-existing-env" | "skipped-existing-fallback" | "skipped-invalid";
 export interface AuthCredentialIfAbsentResult {
@@ -253,8 +259,20 @@ export type OAuthRefreshLeaseClaim = {
 } | {
     kind: "missing";
 };
+/**
+ * Store-owned ticket that orders a provider admission against remote
+ * credential snapshot application. The ticket is intentionally released at
+ * provider admission, not response completion.
+ */
+export interface CredentialDispatchTicket {
+    release(): void;
+}
 export interface AuthCredentialStore {
     close(): void;
+    refreshSnapshot?(signal?: AbortSignal): Promise<unknown>;
+    onSnapshotChanged?(listener: () => void): () => void;
+    /** Order provider admission with remote snapshot authority application. */
+    acquireCredentialDispatchTicket?(provider: Provider, signal?: AbortSignal): Promise<CredentialDispatchTicket>;
     listAuthCredentials(provider?: string): StoredAuthCredential[];
     /** Payload-free account inventory; active and soft-disabled rows are included. */
     listCredentialInventory?(provider?: string): CredentialInventoryRecord[];
@@ -265,6 +283,7 @@ export interface AuthCredentialStore {
     updateAuthCredential(id: number, credential: AuthCredential): void;
     deleteAuthCredential(id: number, disabledCause: string): void;
     tryDisableAuthCredentialIfMatches(id: number, expectedData: string, disabledCause: string): boolean;
+    tryDisableAuthCredentialIfRevision?(id: number, expectedRevision: number, disabledCause: string): boolean;
     replaceAuthCredentialsForProvider(provider: string, credentials: AuthCredential[]): StoredAuthCredential[];
     upsertAuthCredentialForProvider(provider: string, credential: AuthCredential): StoredAuthCredential[];
     upsertAuthCredentialForProviderIfAbsent(provider: string, credential: AuthCredential): AuthCredentialIfAbsentResult;
@@ -273,6 +292,8 @@ export interface AuthCredentialStore {
         includeExpired?: boolean;
     }): string | null;
     setCache(key: string, value: string, expiresAtSec: number): void;
+    /** Atomically allocate a durable sequence for broker restart epochs. */
+    allocateMonotonicSequence(key: string, expiresAtSec: number): number;
     deleteCachePrefix?(prefix: string): void;
     cleanExpiredCache(): void;
     /**
@@ -320,6 +341,7 @@ export interface AuthCredentialStore {
      * `signal` propagates the agent's cancel down to the broker fetch.
      */
     fetchUsageReports?(signal?: AbortSignal): Promise<UsageReport[] | null>;
+    fetchUsageReportsForProvider?(provider: Provider, signal?: AbortSignal): Promise<UsageReport[] | null>;
     /** Synchronous, zero-network usage presentation peek. */
     peekCachedUsagePresentation?(provider: Provider, credentialId: number): CachedUsagePresentation | undefined;
     /** Record a safe usage observation after an explicit fetch/check. */
@@ -360,6 +382,16 @@ export interface AuthCredentialStore {
     markCredentialSuspect?(credentialId: number, opts?: {
         signal?: AbortSignal;
     }): Promise<void>;
+    /**
+     * Optional async write hook to disable one credential through an authoritative
+     * remote store. Remote clients MUST use this hook instead of the synchronous
+     * local delete methods when an OAuth refresh fails definitively.
+     *
+     * Returns `false` when the row is already absent (for example, a peer
+     * disabled it first). Implementations MUST NOT treat a failed remote write as
+     * a successful local deletion.
+     */
+    disableAuthCredentialRemote?(credentialId: number, disabledCause: string, signal?: AbortSignal, expectedRevision?: number): Promise<boolean>;
     /**
      * Optional async write hook for upserting a single credential. When present,
      * `AuthStorage.#upsertOAuthCredential` routes through this instead of the
@@ -468,10 +500,13 @@ export type AuthStorageOptions = {
      * AuthStorage caller surfaces that to its own consumer unchanged.
      */
     fetchUsageReports?: (signal?: AbortSignal) => Promise<UsageReport[] | null>;
+    fetchUsageReportsForProvider?: (provider: Provider, signal?: AbortSignal) => Promise<UsageReport[] | null>;
 };
-type AuthApiKeyOptions = {
+export type AuthApiKeyOptions = {
     baseUrl?: string;
     modelId?: string;
+    /** Select config registrations owned by one caller (for example a ModelRegistry). */
+    owner?: object;
     /**
      * Caller's cancel signal. Threaded into any broker-bound OAuth refresh so
      * `ESC` / request abort actually kills a hung broker fetch instead of
@@ -506,7 +541,11 @@ export interface OAuthAccess {
 export interface InvalidateCredentialMatchingOptions {
     signal?: AbortSignal;
     sessionId?: string;
+    owner?: object;
 }
+/** 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,
@@ -528,9 +567,14 @@ export declare class AuthStorage {
      */
     close(): void;
     getGeneration(): number;
+    getCache(key: string, options?: {
+        includeExpired?: boolean;
+    }): string | null;
+    setCache(key: string, value: string, expiresAtSec: number): void;
+    allocateMonotonicSequence(key: string, expiresAtSec: number): number;
     getProviderConfigurationGeneration(provider: string): number;
     getProviderOAuthRefreshGeneration(provider: string): number;
-    getProviderEvidenceGeneration(provider: string, resolvedApiKey?: string): string;
+    getProviderEvidenceGeneration(provider: string, resolvedApiKey?: string, owner?: object): string;
     onGenerationChanged(listener: (generation: number) => void): () => void;
     offGenerationChanged(listener: (generation: number) => void): void;
     /**
@@ -568,8 +612,12 @@ export declare class AuthStorage {
     hasCredentialScopeLease(scopeId: string): boolean;
     /** Release one credential-scope lease; final release clears only that scope's derived state. */
     releaseCredentialScope(scopeId: string): void;
-    /** Set the selector derived from a durable session pin or a session seed. */
-    setSessionCredentialSelector(scopeId: string, provider: string, selector: AuthCredentialSelector): void;
+    /**
+     * Set the selector derived from a durable session pin or a session seed.
+     * `owner` scopes config-override validation to one ModelRegistry; omitted
+     * owners retain process-wide caller semantics.
+     */
+    setSessionCredentialSelector(scopeId: string, provider: string, selector: AuthCredentialSelector, owner?: object): void;
     /** Explicitly mask persistent/process-global selection and return the provider to AUTO for one scope. */
     setSessionCredentialAuto(provider: string, scopeId: string): void;
     /** Clear a scope's explicit selector and AUTO mask, restoring normal precedence. */
@@ -581,9 +629,13 @@ export declare class AuthStorage {
     /** Resolve the effective selector precedence for a provider/scope. */
     resolveEffectiveCredentialSelector(provider: string, scopeId?: string, explicitSelector?: AuthCredentialSelector): AuthCredentialSelector | undefined;
     /** @internal Return cache provenance for an exact stored literal API-key row without resolving its value. */
-    getStoredLiteralApiKeyEvidenceGeneration(provider: string, selector: AuthCredentialSelector): string | undefined;
-    /** Validate and canonicalize an OAuth-only selector for account pinning. */
-    resolveOAuthPinTarget(provider: string, selector: AuthCredentialSelector): OAuthPinTarget;
+    getStoredLiteralApiKeyEvidenceGeneration(provider: string, selector: AuthCredentialSelector, owner?: object): string | undefined;
+    /**
+     * Validate and canonicalize an OAuth-only selector for account pinning.
+     * `owner` scopes config-override checks to one ModelRegistry; omitted owners
+     * retain process-wide caller semantics.
+     */
+    resolveOAuthPinTarget(provider: string, selector: AuthCredentialSelector, owner?: object): OAuthPinTarget;
     /** Return all local inventory rows, including soft-disabled metadata, without payloads. */
     listCredentialInventory(provider?: string): CredentialInventoryRecord[];
     /** Return local credential hard-removal action targets, including disabled rows. */
@@ -617,7 +669,7 @@ export declare class AuthStorage {
     /** Whether a provider is currently authenticated by a runtime API-key override. */
     hasRuntimeApiKey(provider: string): boolean;
     /** Whether a provider is currently authenticated by a config API-key override. */
-    hasConfigApiKey(provider: string): boolean;
+    hasConfigApiKey(provider: string, owner?: object): boolean;
     /**
      * Whether credential selection for a provider is pinned to one stored row by
      * a runtime selector (`--credential`).
@@ -664,7 +716,8 @@ export declare class AuthStorage {
      * runtime API-key override (`--api-key`), or a config-sourced API key
      * (`models.yml` `apiKey`) would each re-decide the credential on the very
      * next {@link AuthStorage.getApiKey} call and make this switch appear to
-     * silently do nothing.
+     * silently do nothing. `owner` scopes the config-override check to one
+     * ModelRegistry; omitted owners retain process-wide caller semantics.
      *
      * Deliberately does not touch credential-blocked state: if the target row
      * is still backoff-blocked from a prior quota failure, the existing
@@ -672,7 +725,7 @@ export declare class AuthStorage {
      * falls back to a usable account instead of re-issuing a request that would
      * just draw another 429/quota error.
      */
-    switchSessionCredential(provider: string, sessionId: string, selector: AuthCredentialSelector): void;
+    switchSessionCredential(provider: string, sessionId: string, selector: AuthCredentialSelector, owner?: object): void;
     /**
      * Register a per-provider API key sourced from user configuration
      * (e.g. `models.yml` `providers.<name>.apiKey`). Higher priority than
@@ -682,26 +735,46 @@ export declare class AuthStorage {
      *
      * Lower priority than {@link setRuntimeApiKey} so a CLI `--api-key`
      * still wins for the duration of a single invocation.
-     */
-    setConfigApiKey(provider: string, apiKey: string): void;
+     *
+     * `options.owner` scopes the override to one registry or other caller. The
+     * unscoped form is process-wide and is retained for standalone callers.
+     *
+     * `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, options?: {
+        envSourced?: boolean;
+        owner?: object;
+    }): void;
     /**
      * Remove a single config-sourced API key override.
      */
-    removeConfigApiKey(provider: string): void;
+    removeConfigApiKey(provider: string, owner?: object): void;
     /**
-     * Drop every config-sourced API key. Called by `ModelRegistry` before
-     * re-parsing `models.yml` so removed entries actually disappear.
+     * Drop config-sourced API keys. An owner removes only its own registrations;
+     * the unscoped form remains an explicit global reset for callers that own the
+     * entire AuthStorage instance.
      */
-    clearConfigApiKeys(): void;
+    clearConfigApiKeys(owner?: object): void;
     /**
      * Set a fallback resolver for API keys not found in storage or env vars.
      * Used for custom provider keys from models.json.
      */
-    setFallbackResolver(resolver: (provider: string) => string | undefined): void;
+    setFallbackResolver(resolver: (provider: string) => string | undefined, owner?: object): () => void;
     /**
      * Reload credentials from storage.
      */
     reload(): Promise<void>;
+    /**
+     * Acquire a store-owned provider-admission ticket when the backing store
+     * provides one (for example, a remote broker snapshot store). Local stores
+     * need no additional ordering and return `undefined`.
+     */
+    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;
     /**
@@ -712,7 +785,7 @@ export declare class AuthStorage {
      * Set credential for a provider.
      */
     set(provider: string, credential: AuthCredentialEntry): Promise<void>;
-    importCredentialIfAbsent(provider: string, credential: AuthCredential): Promise<AuthCredentialIfAbsentSnapshotResult>;
+    importCredentialIfAbsent(provider: string, credential: AuthCredential, owner?: object): Promise<AuthCredentialIfAbsentSnapshotResult>;
     /**
      * Remove credential for a provider.
      */
@@ -725,17 +798,18 @@ export declare class AuthStorage {
      * Check if credentials exist for a provider in storage.
      */
     has(provider: string): boolean;
-    hasAuth(provider: string, sessionId?: string): boolean;
+    disableCredentialByIdIfRevision(id: number, expectedRevision: number, disabledCause: string): boolean;
+    hasAuth(provider: string, sessionId?: string, options?: Pick<AuthApiKeyOptions, "owner">): boolean;
     /**
      * Credential type that a provider/session will dispatch first without performing I/O.
      * Mirrors getApiKey selector validation, overrides, session OAuth stickiness,
      * cached command-key usability, OAuth retry, and environment fallback order.
      */
-    getEffectiveCredentialType(provider: string, sessionId?: string): AuthCredential["type"] | undefined;
+    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): boolean;
+    hasUsableAuth(provider: string, options?: Pick<AuthApiKeyOptions, "owner">): boolean;
     /**
      * Check if OAuth credentials are configured for a provider.
      */
@@ -743,7 +817,7 @@ export declare class AuthStorage {
     /**
      * Get OAuth credentials for a provider.
      */
-    getOAuthCredential(provider: string, sessionId?: string): OAuthCredential | undefined;
+    getOAuthCredential(provider: string, sessionId?: string, options?: Pick<AuthApiKeyOptions, "owner">): OAuthCredential | undefined;
     /**
      * Get the OAuth `accountId` for a provider, preferring the credential that is
      * session-sticky for `sessionId` when multiple OAuth credentials are configured.
@@ -751,7 +825,7 @@ export declare class AuthStorage {
      * first call before any `getApiKey` has been issued, or single-credential setups).
      * Returns `undefined` when no OAuth credential carries an `accountId`.
      */
-    getOAuthAccountId(provider: string, sessionId?: string): string | undefined;
+    getOAuthAccountId(provider: string, sessionId?: string, options?: Pick<AuthApiKeyOptions, "owner">): string | undefined;
     /**
      * Get all credentials.
      */
@@ -776,6 +850,7 @@ export declare class AuthStorage {
      */
     logout(provider: string): Promise<void>;
     fetchUsageReports(options?: {
+        provider?: Provider;
         baseUrlResolver?: (provider: Provider) => string | undefined;
         /** Caller's cancel signal; only rejects this caller, never the shared upstream fetch. */
         signal?: AbortSignal;
@@ -820,6 +895,7 @@ export declare class AuthStorage {
         retryAfterMs?: number;
         baseUrl?: string;
         signal?: AbortSignal;
+        owner?: object;
     }): Promise<boolean>;
     /**
      * Earliest instant at which any currently blocked stored credential for this
@@ -835,18 +911,21 @@ 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): Promise<string | undefined>;
+    peekApiKey(provider: string, options?: Pick<AuthApiKeyOptions, "owner">): Promise<string | undefined>;
     /**
      * 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,14 +994,16 @@ 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.
      *
      * The string is purely informational; consumers must not parse it.
      */
-    describeCredentialSource(provider: string, sessionId?: string): string | undefined;
+    describeCredentialSource(provider: string, sessionId?: string, options?: Pick<AuthApiKeyOptions, "owner">): string | undefined;
 }
 /**
  * Default SQLite-backed implementation of {@link AuthCredentialStore}.
@@ -955,11 +1036,13 @@ export declare class SqliteAuthCredentialStore implements AuthCredentialStore {
      * row between our pre-check and the disable.
      */
     tryDisableAuthCredentialIfMatches(id: number, expectedData: string, disabledCause: string): boolean;
+    tryDisableAuthCredentialIfRevision(id: number, expectedRevision: number, disabledCause: string): boolean;
     deleteAuthCredentialsForProvider(provider: string, disabledCause: string): void;
     getCache(key: string, options?: {
         includeExpired?: boolean;
     }): string | null;
     setCache(key: string, value: string, expiresAtSec: number): void;
+    allocateMonotonicSequence(key: string, expiresAtSec: number): number;
     deleteCachePrefix(prefix: string): void;
     cleanExpiredCache(): void;
     /**
@@ -989,4 +1072,3 @@ export declare class SqliteAuthCredentialStore implements AuthCredentialStore {
     deleteProvider(provider: string): void;
     close(): void;
 }
-export {};

package/dist/types/provider-models/openai-compat.d.ts

@@ -98,6 +98,7 @@ export interface OpenCodeModelManagerConfig {
 }
 export declare function opencodeZenModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export declare function opencodeGoModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export declare function commandCodeModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
 export interface OllamaModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;

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/providers/register-builtins.d.ts

@@ -44,16 +44,16 @@ export declare function resolveLazyStreamFirstEventFallbackMs(provider: string,
 export declare const PROVIDER_RUNTIME_DESCRIPTORS: readonly ProviderRuntimeDescriptor<Api, unknown>[];
 /** Return the lazy descriptor for a built-in API, if one is registered. */
 export declare function getProviderRuntimeDescriptor<TApi extends Api>(api: TApi): ProviderRuntimeDescriptor<TApi, unknown> | undefined;
-export declare const streamAnthropic: (model: Model<"anthropic-messages">, context: Context, options: OptionsForApi<"anthropic-messages">) => EventStreamImpl;
-export declare const streamAzureOpenAIResponses: (model: Model<"azure-openai-responses">, context: Context, options: OptionsForApi<"azure-openai-responses">) => EventStreamImpl;
-export declare const streamGoogle: (model: Model<"google-generative-ai">, context: Context, options: OptionsForApi<"google-generative-ai">) => EventStreamImpl;
-export declare const streamGoogleGeminiCli: (model: Model<"google-gemini-cli">, context: Context, options: OptionsForApi<"google-gemini-cli">) => EventStreamImpl;
-export declare const streamGoogleVertex: (model: Model<"google-vertex">, context: Context, options: OptionsForApi<"google-vertex">) => EventStreamImpl;
-export declare const streamOpenAICodexResponses: (model: Model<"openai-codex-responses">, context: Context, options: OptionsForApi<"openai-codex-responses">) => EventStreamImpl;
-export declare const streamOpenAICompletions: (model: Model<"openai-completions">, context: Context, options: OptionsForApi<"openai-completions">) => EventStreamImpl;
-export declare const streamOpenAIResponses: (model: Model<"openai-responses">, context: Context, options: OptionsForApi<"openai-responses">) => EventStreamImpl;
-export declare const streamCursor: (model: Model<"cursor-agent">, context: Context, options: OptionsForApi<"cursor-agent">) => EventStreamImpl;
-export declare const streamOllama: (model: Model<"ollama-chat">, context: Context, options: OptionsForApi<"ollama-chat">) => EventStreamImpl;
-export declare const streamBedrock: (model: Model<"bedrock-converse-stream">, context: Context, options: OptionsForApi<"bedrock-converse-stream">) => EventStreamImpl;
-export declare const streamKiroCodeWhisperer: (model: Model<"kiro-codewhisperer-stream">, context: Context, options: OptionsForApi<"kiro-codewhisperer-stream">) => EventStreamImpl;
+export declare const streamAnthropic: (model: Model<"anthropic-messages">, context: Context, options: OptionsForApi<"anthropic-messages">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamAzureOpenAIResponses: (model: Model<"azure-openai-responses">, context: Context, options: OptionsForApi<"azure-openai-responses">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamGoogle: (model: Model<"google-generative-ai">, context: Context, options: OptionsForApi<"google-generative-ai">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamGoogleGeminiCli: (model: Model<"google-gemini-cli">, context: Context, options: OptionsForApi<"google-gemini-cli">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamGoogleVertex: (model: Model<"google-vertex">, context: Context, options: OptionsForApi<"google-vertex">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamOpenAICodexResponses: (model: Model<"openai-codex-responses">, context: Context, options: OptionsForApi<"openai-codex-responses">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamOpenAICompletions: (model: Model<"openai-completions">, context: Context, options: OptionsForApi<"openai-completions">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamOpenAIResponses: (model: Model<"openai-responses">, context: Context, options: OptionsForApi<"openai-responses">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamCursor: (model: Model<"cursor-agent">, context: Context, options: OptionsForApi<"cursor-agent">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamOllama: (model: Model<"ollama-chat">, context: Context, options: OptionsForApi<"ollama-chat">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamBedrock: (model: Model<"bedrock-converse-stream">, context: Context, options: OptionsForApi<"bedrock-converse-stream">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamKiroCodeWhisperer: (model: Model<"kiro-codewhisperer-stream">, context: Context, options: OptionsForApi<"kiro-codewhisperer-stream">, onStreamCreated?: () => void) => EventStreamImpl;
 export {};

package/dist/types/stream.d.ts

@@ -29,12 +29,13 @@ export declare function listProvidersWithEnvKey(): string[];
  * handling, so callers can append it unconditionally.
  */
 export declare function formatProviderCredentialHint(provider: string): string;
+export declare function streamFromLazyImport(createInner: () => Promise<AssistantMessageEventStream>, signal?: AbortSignal, onStreamCreated?: () => void): AssistantMessageEventStream;
 /**
  * Build an actionable "missing API key" error for a provider, used by the
  * low-level `stream`/`complete` entry points (#755).
  */
 export declare function formatMissingApiKeyError(provider: string): string;
-export declare function stream<TApi extends Api>(model: Model<TApi>, context: Context, options?: OptionsForApi<TApi>): AssistantMessageEventStream;
+export declare function stream<TApi extends Api>(model: Model<TApi>, context: Context, options?: OptionsForApi<TApi>, onStreamCreated?: () => void): AssistantMessageEventStream;
 export declare function complete<TApi extends Api>(model: Model<TApi>, context: Context, options?: OptionsForApi<TApi>): Promise<AssistantMessage>;
 export declare function streamSimple<TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
 export declare function completeSimple<TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions): Promise<AssistantMessage>;

package/dist/types/types.d.ts

@@ -54,7 +54,7 @@ export interface ThinkingConfig {
     /** Provider-specific transport used to encode the selected effort. */
     mode: ThinkingControlMode;
 }
-export declare const KNOWN_PROVIDERS: readonly ["alibaba-token-plan", "amazon-bedrock", "kiro", "azure-openai", "anthropic", "google", "google-gemini-cli", "google-antigravity", "google-vertex", "openai", "openai-codex", "opencodex", "kimi-code", "minimax-code", "minimax-code-cn", "github-copilot", "fireworks", "firepass", "fugu", "gitlab-duo", "cursor", "jetbrains-junie", "deepseek", "deepinfra", "xai", "groq", "cerebras", "openrouter", "kilo", "vercel-ai-gateway", "zai", "glm-zcode", "mistral", "minimax", "opencode-go", "opencode-zen", "opengateway", "bizrouter", "mara", "synthetic", "cloudflare-ai-gateway", "huggingface", "litellm", "moonshot", "nvidia", "nanogpt", "ollama", "ollama-cloud", "qianfan", "qwen-portal", "sglang", "together", "venice", "vllm", "xiaomi", "xiaomi-token-plan-sgp", "xiaomi-token-plan-ams", "xiaomi-token-plan-cn", "zenmux", "lm-studio", "omlx"];
+export declare const KNOWN_PROVIDERS: readonly ["alibaba-token-plan", "amazon-bedrock", "kiro", "azure-openai", "anthropic", "google", "google-gemini-cli", "google-antigravity", "google-vertex", "openai", "openai-codex", "opencodex", "kimi-code", "minimax-code", "minimax-code-cn", "github-copilot", "fireworks", "firepass", "fugu", "gitlab-duo", "cursor", "jetbrains-junie", "deepseek", "deepinfra", "xai", "groq", "cerebras", "openrouter", "kilo", "vercel-ai-gateway", "zai", "glm-zcode", "mistral", "minimax", "opencode-go", "commandcode-goat", "opencode-zen", "opengateway", "bizrouter", "mara", "synthetic", "cloudflare-ai-gateway", "huggingface", "litellm", "moonshot", "nvidia", "nanogpt", "ollama", "ollama-cloud", "qianfan", "qwen-portal", "sglang", "together", "venice", "vllm", "xiaomi", "xiaomi-token-plan-sgp", "xiaomi-token-plan-ams", "xiaomi-token-plan-cn", "zenmux", "lm-studio", "omlx"];
 export type KnownProvider = (typeof KNOWN_PROVIDERS)[number];
 export declare function isKnownProvider(provider: string): provider is KnownProvider;
 export type Provider = KnownProvider | string;
@@ -155,6 +155,18 @@ export interface RawSseEvent {
 export type FetchImpl = ((input: string | URL | Request, init?: RequestInit) => Promise<Response>) & {
     preconnect?: typeof globalThis.fetch.preconnect;
 };
+/**
+ * Credential returned by an auth retry resolver.
+ *
+ * The optional admission callback lets an authority-bearing caller retain a
+ * credential lease until the replacement provider request is actually
+ * admitted. Ordinary callers can continue returning a string from
+ * {@link StreamOptions.onAuthError}.
+ */
+export interface AuthRetryCredential {
+    apiKey: string;
+    onStreamCreated?: () => void;
+}
 export interface StreamOptions {
     temperature?: number;
     topP?: number;
@@ -186,7 +198,7 @@ export interface StreamOptions {
      * event has been emitted. Returning a different key retries the provider
      * request once.
      */
-    onAuthError?: (provider: string, apiKey: string, error: unknown) => Promise<string | undefined>;
+    onAuthError?: (provider: string, apiKey: string, error: unknown) => Promise<string | AuthRetryCredential | undefined>;
     cacheRetention?: CacheRetention;
     /**
      * Additional headers to include in provider requests.
@@ -243,6 +255,14 @@ export interface StreamOptions {
      * The `scope` parameter carries the per-attempt identity for execution attribution.
      */
     onResponse?: (response: ProviderResponseMetadata, model?: Model<Api>, scope?: AttemptScopeRef) => void | Promise<void>;
+    /**
+     * Internal dispatch-admission hook. Providers invoke this immediately before
+     * submitting an outbound request; stream forwarding retains a first-response
+     * fallback for custom providers that do not expose a transport seam.
+     */
+    onStreamCreated?: () => void;
+    /** Internal authority policy: disable provider-owned retries and corrective replays. */
+    disableProviderRetries?: boolean;
     /**
      * Optional callback for raw Server-Sent Events as they arrive from HTTP streaming providers.
      *
@@ -399,31 +419,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. */