agent-afk 5.115.4 → 5.117.0

package/dist/agent/auth/credential-resolver.d.ts

@@ -1,3 +1,6 @@
+import { type ProviderRouteHints } from '../providers/index.js';
 export declare function loadAnthropicCredential(): string | undefined;
 export declare function loadOpenAICredential(): string | undefined;
-export declare function resolveCredentialForModel(model: string | undefined): string | undefined;
+export declare function loadXaiApiKey(): string | undefined;
+export declare function loadXaiCredential(): string | undefined;
+export declare function resolveCredentialForModel(model: string | undefined, hints?: ProviderRouteHints): string | undefined;

package/dist/agent/auth/model-availability.d.ts

@@ -1,5 +1,5 @@
 import { type ModelSlots } from '../session/model-slots.js';
-export type AvailabilityNeed = 'anthropic' | 'openai' | 'chatgpt-oauth' | 'local' | 'unknown';
+export type AvailabilityNeed = 'anthropic' | 'openai' | 'chatgpt-oauth' | 'xai' | 'xai-oauth' | 'local' | 'unknown';
 export interface ModelAvailability {
     available: boolean;
     needs: AvailabilityNeed;

package/dist/agent/providers/index.d.ts

@@ -1,7 +1,7 @@
 import type { ModelProvider } from '../provider.js';
 import { anthropicDirectProvider } from './anthropic-direct/index.js';
 import { type ModelSlots } from '../session/model-slots.js';
-export type BundledProviderName = 'anthropic' | 'anthropic-direct' | 'openai-compatible' | 'openai-codex';
+export type BundledProviderName = 'anthropic' | 'anthropic-direct' | 'openai-compatible' | 'openai-codex' | 'xai' | 'xai-oauth';
 export interface ProviderRouteHints {
     explicit?: string;
     openaiBaseUrl?: string;
@@ -15,3 +15,4 @@ export declare function resolveProvider(model: string | undefined, hints?: Provi
 export { anthropicDirectProvider };
 export { AnthropicDirectProvider } from './anthropic-direct/index.js';
 export { OpenAICompatibleProvider, openaiCompatibleProvider } from './openai-compatible/index.js';
+export { XaiProvider } from './xai/index.js';

package/dist/agent/providers/openai-compatible/index.d.ts

@@ -9,6 +9,7 @@ import type { ToolDispatcher } from '../anthropic-direct/tool-dispatcher.js';
 import { MemoryStore } from '../../memory/index.js';
 export interface OpenAICompatibleProviderOptions {
     baseURL?: string;
+    defaultHeaders?: Record<string, string>;
     hookRegistry?: HookRegistry;
     permissions?: ToolPermissionConfig;
     canUseTool?: CanUseTool;
@@ -28,6 +29,7 @@ export declare class OpenAICompatibleProvider implements ModelProvider {
     private readonly providerOpts;
     private readonly memoryStore;
     private readonly schemas;
+    private _defaultHeaders;
     private _sharedReadRoots;
     private _sharedWriteRoots;
     private _currentPermissionMode;
@@ -35,6 +37,10 @@ export declare class OpenAICompatibleProvider implements ModelProvider {
     private _presenceSessionId;
     private _mintedSessionId;
     constructor(opts?: OpenAICompatibleProviderOptions);
+    setEndpointDefaults(defaults: {
+        baseURL?: string;
+        defaultHeaders?: Record<string, string>;
+    }): void;
     query(args: ProviderQueryArgs): ProviderQuery;
     private buildDispatcher;
     private ensureSharedRoots;

package/dist/agent/providers/openai-compatible/oneshot.d.ts

@@ -6,11 +6,13 @@ export declare class ResponsesSummaryIncompleteError extends Error {
 export type OneShotOpenAIClientFactory = (opts: {
     apiKey: string;
     baseURL?: string;
+    defaultHeaders?: Record<string, string>;
 }) => OpenAI;
 export declare function __setOpenAIOneShotClientFactory(factory: OneShotOpenAIClientFactory | null): void;
 export interface OpenAIOneShotInput {
     apiKey?: string;
     baseURL?: string;
+    defaultHeaders?: Record<string, string>;
     model: string;
     system: string;
     user: string;

package/dist/agent/providers/openai-compatible/query.d.ts

@@ -12,6 +12,7 @@ export { resolveReasoningEffort };
 export interface OpenAICompatibleQueryOptions {
     auth: OpenAIAuthResolution;
     baseURL?: string;
+    defaultHeaders?: Record<string, string>;
     model: string;
     synthesizedSessionId: string;
     promptStream: AsyncIterable<ProviderUserTurn>;
@@ -71,6 +72,7 @@ export declare class OpenAICompatibleQuery implements ProviderQuery {
 }
 export declare function buildQueryFromConfig(config: AgentConfig, promptStream: AsyncIterable<ProviderUserTurn>, options?: {
     baseURL?: string;
+    defaultHeaders?: Record<string, string>;
     toolDispatcher?: ToolDispatcher;
     onPermissionMode?: (mode: string) => void;
     onCwdChange?: (cwd: string) => void;

package/dist/agent/providers/xai/auth-store.d.ts

@@ -0,0 +1,22 @@
+export declare function getXaiAuthPath(): string;
+export interface XaiTokenBundle {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    token_type?: string;
+    scope?: string;
+}
+export interface XaiAuthStoreDeps {
+    authPath?: () => string;
+    readFile?: (path: string) => string | null;
+    writeFile?: (path: string, data: string, mode: number) => void;
+    chmod?: (path: string, mode: number) => void;
+    mkdir?: (dir: string) => void;
+    unlink?: (path: string) => void;
+    exists?: (path: string) => boolean;
+}
+export declare function parseXaiTokenBundle(raw: string): XaiTokenBundle | null;
+export declare function readXaiTokens(deps?: XaiAuthStoreDeps): XaiTokenBundle | null;
+export declare function writeXaiTokens(bundle: XaiTokenBundle, deps?: XaiAuthStoreDeps): void;
+export declare function clearXaiTokens(deps?: XaiAuthStoreDeps): void;
+export declare function last4OfToken(token: string): string;

package/dist/agent/providers/xai/auth.d.ts

@@ -0,0 +1,26 @@
+import { type XaiAuthStoreDeps } from './auth-store.js';
+import type { XaiAuthMode } from './endpoints.js';
+export type XaiAuthSource = 'config' | 'env' | 'xai-oauth' | 'no-usable-auth' | 'no-usable-auth-forced-xai-oauth' | 'no-usable-auth-forced-xai-apikey' | 'ambiguous-auth';
+export interface XaiAuthResolution {
+    apiKey: string | null;
+    source: XaiAuthSource;
+    mode?: XaiAuthMode;
+    last4?: string;
+    expiresAt?: number;
+    envVar?: 'XAI_API_KEY';
+}
+export interface XaiAuthResolverDeps {
+    readEnv?: (key: string) => string | undefined;
+    store?: XaiAuthStoreDeps;
+    nowSeconds?: () => number;
+}
+export type XaiAuthForceMode = 'apikey' | 'oauth' | undefined;
+export declare function resolveXaiAuth(explicitConfigKey: string | undefined, forceMode?: XaiAuthForceMode, deps?: XaiAuthResolverDeps): XaiAuthResolution;
+export declare function formatXaiAuthDiagnostic(resolution: XaiAuthResolution, deps?: {
+    nowSeconds?: () => number;
+}): string;
+export declare function formatXaiHttpAuthError(status: number, opts: {
+    mode: XaiAuthMode;
+    baseURL?: string;
+    bodySnippet?: string;
+}): string;

package/dist/agent/providers/xai/endpoints.d.ts

@@ -0,0 +1,15 @@
+export type XaiAuthMode = 'apikey' | 'oauth';
+export declare const DEFAULT_XAI_API_BASE_URL = "https://api.x.ai/v1";
+export declare const DEFAULT_XAI_OAUTH_BASE_URL = "https://cli-chat-proxy.grok.com/v1";
+export interface XaiEndpointResolution {
+    baseURL: string;
+    defaultHeaders: Record<string, string>;
+    mode: XaiAuthMode;
+    proxyHeadersApplied: boolean;
+}
+export interface XaiEndpointDeps {
+    readEnv?: (key: string) => string | undefined;
+    clientVersion?: string;
+    baseUrlOverride?: string;
+}
+export declare function resolveXaiEndpoint(mode: XaiAuthMode, deps?: XaiEndpointDeps): XaiEndpointResolution;

package/dist/agent/providers/xai/force-mode.d.ts

@@ -0,0 +1,4 @@
+import type { XaiAuthForceMode } from './auth.js';
+export declare function resolveXaiForceMode(constructionMode: XaiAuthForceMode, forceXaiOAuth: boolean | undefined, forceXaiApiKey?: boolean | undefined): XaiAuthForceMode;
+export declare function resolveCompleteForceMode(constructionMode: XaiAuthForceMode, lastResolvedMode: 'apikey' | 'oauth' | undefined): XaiAuthForceMode;
+export declare function resolveXaiConstructionAuthMode(effective: 'xai' | 'xai-oauth', wasExplicitProvider: boolean): XaiAuthForceMode;

package/dist/agent/providers/xai/headers.d.ts

@@ -0,0 +1,7 @@
+export declare const CLI_CHAT_PROXY_HOST = "cli-chat-proxy.grok.com";
+export interface GrokCliHeaderOptions {
+    clientVersion?: string;
+    clientIdentifier?: string;
+}
+export declare function isCliChatProxyBaseUrl(baseURL: string): boolean;
+export declare function resolveGrokCliIdentityHeaders(opts?: GrokCliHeaderOptions): Record<string, string>;

package/dist/agent/providers/xai/index.d.ts

@@ -0,0 +1,38 @@
+import type { ModelProvider, ProviderQuery, ProviderQueryArgs, ProviderCompleteArgs } from '../../provider.js';
+import type { OpenAICompatibleProviderOptions } from '../openai-compatible/index.js';
+import { type XaiAuthForceMode, type XaiAuthResolverDeps } from './auth.js';
+export { resolveXaiForceMode, resolveCompleteForceMode } from './force-mode.js';
+export interface XaiProviderOptions extends OpenAICompatibleProviderOptions {
+    authMode?: XaiAuthForceMode;
+    authDeps?: XaiAuthResolverDeps;
+}
+export declare class XaiProvider implements ModelProvider {
+    readonly name = "xai";
+    private readonly inner;
+    private readonly authMode;
+    private readonly authDeps;
+    private lastMode;
+    private lastResolvedMode;
+    private lastXaiBaseUrl;
+    constructor(opts?: XaiProviderOptions);
+    query(args: ProviderQueryArgs): ProviderQuery;
+    private querySync;
+    private delegateToInner;
+    private rememberResolved;
+    addReadRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
+    addWriteRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
+    revokeRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
+    getGrants(): {
+        resolveBase: string | undefined;
+        readRoots: string[];
+        writeRoots: string[];
+        allowAll: boolean;
+    };
+    close(): void;
+    complete(args: ProviderCompleteArgs): Promise<string>;
+}
+export { resolveXaiAuth, formatXaiAuthDiagnostic, formatXaiHttpAuthError, type XaiAuthResolution, type XaiAuthSource, } from './auth.js';
+export { resolveXaiEndpoint, DEFAULT_XAI_API_BASE_URL, DEFAULT_XAI_OAUTH_BASE_URL, type XaiAuthMode, } from './endpoints.js';
+export { readXaiTokens, writeXaiTokens, clearXaiTokens, getXaiAuthPath, } from './auth-store.js';
+export { startDeviceCodeFlow, pollDeviceCodeToken, buildPkceAuthorizeUrl, exchangeAuthorizationCode, generateCodeVerifier, generateOAuthState, refreshXaiTokens, ensureFreshAccessToken, discoverXaiOidc, } from './oauth.js';
+export { deriveXaiCallCostUsd, isGrokModelId, XAI_MODEL_PRICING, } from './pricing.js';

package/dist/agent/providers/xai/oauth-constants.d.ts

@@ -0,0 +1,10 @@
+export declare const XAI_OAUTH_ISSUER = "https://auth.x.ai";
+export declare const XAI_OAUTH_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+export declare const XAI_OAUTH_SCOPES_BASE = "openid profile email offline_access grok-cli:access api:access";
+export declare const XAI_OAUTH_SCOPES_EXTENDED = "openid profile email offline_access grok-cli:access api:access conversations:read conversations:write";
+export declare const XAI_OAUTH_SCOPES = "openid profile email offline_access grok-cli:access api:access";
+export declare const XAI_OAUTH_LOOPBACK_PORT = 56121;
+export declare const XAI_OAUTH_REDIRECT_URI = "http://127.0.0.1:56121/callback";
+export declare const XAI_OAUTH_AUTHORIZE_PLAN = "generic";
+export declare const XAI_OAUTH_AUTHORIZE_REFERRER = "https://grok.com";
+export declare const XAI_REFRESH_SKEW_SECONDS: number;

package/dist/agent/providers/xai/oauth-device.d.ts

@@ -0,0 +1,32 @@
+import type { XaiTokenBundle } from './auth-store.js';
+import { type OAuthHttpDeps, type XaiOidcDiscovery } from './oauth-http.js';
+export interface DeviceCodeStart {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete?: string;
+    expires_in: number;
+    interval: number;
+}
+export type DevicePollResult = {
+    status: 'pending';
+} | {
+    status: 'slow_down';
+    interval: number;
+} | {
+    status: 'expired';
+} | {
+    status: 'denied';
+} | {
+    status: 'success';
+    tokens: XaiTokenBundle;
+} | {
+    status: 'error';
+    message: string;
+};
+export declare function positiveSeconds(value: unknown, defaultSeconds: number): number;
+export declare function startDeviceCodeFlow(deps?: OAuthHttpDeps): Promise<{
+    discovery: XaiOidcDiscovery;
+    device: DeviceCodeStart;
+}>;
+export declare function pollDeviceCodeToken(discovery: XaiOidcDiscovery, deviceCode: string, deps?: OAuthHttpDeps): Promise<DevicePollResult>;

package/dist/agent/providers/xai/oauth-http.d.ts

@@ -0,0 +1,20 @@
+import type { XaiTokenBundle } from './auth-store.js';
+export type FetchFn = typeof fetch;
+export interface XaiOidcDiscovery {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    device_authorization_endpoint?: string;
+    userinfo_endpoint?: string;
+}
+export interface OAuthHttpDeps {
+    fetchFn?: FetchFn;
+    issuer?: string;
+    clientId?: string;
+    scopes?: string;
+    nowSeconds?: () => number;
+}
+export declare function asNonEmptyString(v: unknown): string | undefined;
+export declare function safeText(res: Response): Promise<string>;
+export declare function discoverXaiOidc(deps?: OAuthHttpDeps): Promise<XaiOidcDiscovery>;
+export declare function tokenResponseToBundle(json: Record<string, unknown>, nowSeconds?: () => number, fallbackRefresh?: string): XaiTokenBundle | null;

package/dist/agent/providers/xai/oauth-pkce.d.ts

@@ -0,0 +1,23 @@
+import type { XaiTokenBundle } from './auth-store.js';
+import { type OAuthHttpDeps, type XaiOidcDiscovery } from './oauth-http.js';
+export interface PkceAuthorizeParams {
+    authorizationUrl: string;
+    codeVerifier: string;
+    state: string;
+    redirectUri: string;
+}
+export declare function generateCodeVerifier(): string;
+export declare function codeChallengeS256(verifier: string): string;
+export declare function generateOAuthState(): string;
+export declare function buildPkceAuthorizeUrl(discovery: XaiOidcDiscovery, opts: {
+    codeVerifier: string;
+    state: string;
+    redirectUri?: string;
+    clientId?: string;
+    scopes?: string;
+}): PkceAuthorizeParams;
+export declare function exchangeAuthorizationCode(discovery: XaiOidcDiscovery, params: {
+    code: string;
+    codeVerifier: string;
+    redirectUri?: string;
+}, deps?: OAuthHttpDeps): Promise<XaiTokenBundle>;

package/dist/agent/providers/xai/oauth.d.ts

@@ -0,0 +1,14 @@
+import { type XaiAuthStoreDeps, type XaiTokenBundle } from './auth-store.js';
+import { type OAuthHttpDeps } from './oauth-http.js';
+export type { FetchFn, OAuthHttpDeps, XaiOidcDiscovery } from './oauth-http.js';
+export { discoverXaiOidc, tokenResponseToBundle } from './oauth-http.js';
+export { startDeviceCodeFlow, pollDeviceCodeToken, type DeviceCodeStart, type DevicePollResult, } from './oauth-device.js';
+export { buildPkceAuthorizeUrl, codeChallengeS256, exchangeAuthorizationCode, generateCodeVerifier, generateOAuthState, type PkceAuthorizeParams, } from './oauth-pkce.js';
+export declare function refreshXaiTokens(refreshToken: string, deps?: OAuthHttpDeps & {
+    store?: XaiAuthStoreDeps;
+    persist?: boolean;
+}): Promise<XaiTokenBundle>;
+export declare function ensureFreshAccessToken(deps?: OAuthHttpDeps & {
+    store?: XaiAuthStoreDeps;
+    skewSeconds?: number;
+}): Promise<XaiTokenBundle | null>;

package/dist/agent/providers/xai/pricing.d.ts

@@ -0,0 +1,8 @@
+export interface XaiModelPricing {
+    inputPerMTok: number;
+    outputPerMTok: number;
+    cachedInputPerMTok?: number;
+}
+export declare const XAI_MODEL_PRICING: ReadonlyMap<string, XaiModelPricing>;
+export declare function isGrokModelId(model: string): boolean;
+export declare function deriveXaiCallCostUsd(model: string, inputTokens: number, outputTokens: number, cachedInputTokens?: number): number | undefined;

package/dist/agent/providers/xai/query-bootstrap.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderQuery, ProviderQueryArgs } from '../../provider.js';
+import { type XaiAuthForceMode, type XaiAuthResolverDeps } from './auth.js';
+import type { XaiAuthMode } from './endpoints.js';
+export interface XaiQueryBootstrapArgs {
+    args: ProviderQueryArgs;
+    forceMode: XaiAuthForceMode;
+    authDeps: XaiAuthResolverDeps;
+    getLastMode: () => XaiAuthMode;
+    delegate: (args: ProviderQueryArgs, apiKey: string, mode: XaiAuthMode) => ProviderQuery;
+}
+export declare function buildOAuthRefreshQuery(opts: XaiQueryBootstrapArgs): ProviderQuery;

package/dist/agent/providers/xai/query-helpers.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderQuery } from '../../provider.js';
+import { type XaiAuthMode } from './endpoints.js';
+export declare function isAccessTokenExpired(expiresAt: number | undefined): boolean;
+export declare function rewriteXaiHttpError(error: unknown, mode: XaiAuthMode): Error;
+export declare function errorOnlyQuery(message: string): ProviderQuery;

package/dist/agent/session/model-slots.d.ts

@@ -1,6 +1,6 @@
 export type SlotName = 'local' | 'small' | 'medium' | 'large';
 export declare const SLOT_NAMES: readonly SlotName[];
-export type SlotProvider = 'anthropic' | 'openai' | 'chatgpt-oauth';
+export type SlotProvider = 'anthropic' | 'openai' | 'chatgpt-oauth' | 'xai' | 'xai-oauth';
 export interface ModelSlotBinding {
     id: string;
     name?: string;

package/dist/agent/session/slot-credentials.d.ts

@@ -5,5 +5,8 @@ export interface SlotCredentialTarget {
     baseUrl?: string;
     openaiBaseUrl?: string;
     forceChatgptOAuth?: boolean;
+    forceXaiOAuth?: boolean;
+    forceXaiApiKey?: boolean;
+    xaiBaseUrl?: string;
 }
 export declare function applySlotCredentials(config: SlotCredentialTarget, bindings?: ModelSlots): void;

package/dist/agent/tools/child-credential.d.ts

@@ -11,3 +11,4 @@ export declare function applyManagerApiKeyFallback(args: {
     parentApiKey: string | undefined;
     parentProvider?: BundledProviderName | undefined;
 }): string | undefined;
+export declare function sameCredentialFamily(a: BundledProviderName, b: BundledProviderName): boolean;

package/dist/agent/types/config-types.d.ts

@@ -26,6 +26,9 @@ export interface AgentConfig {
     baseUrl?: string;
     openaiBaseUrl?: string;
     forceChatgptOAuth?: boolean;
+    forceXaiOAuth?: boolean;
+    forceXaiApiKey?: boolean;
+    xaiBaseUrl?: string;
     maxTurns?: number;
     maxToolUseIterations?: number;
     softDeadlineMs?: number;

package/dist/cli/commands/doctor-checks.d.ts

@@ -7,6 +7,7 @@ export interface Check {
 }
 export declare function checkAnthropicKey(): Promise<Check>;
 export declare function checkCodexKey(): Promise<Check>;
+export declare function checkXaiAuth(): Promise<Check>;
 export declare function checkNpmBinOnPath(): Promise<Check>;
 export declare function checkDirWritable(name: string, getDir: () => string): Promise<Check>;
 export declare function checkConfigFile(): Promise<Check>;

package/dist/cli/commands/interactive/bootstrap-session-builder.d.ts

@@ -24,6 +24,7 @@ export interface BuildAgentSessionDeps {
     autoResumeOnUsageLimit: boolean | undefined;
     permissionMode?: PermissionMode;
     baseUrl?: string;
+    explicitProvider?: string;
 }
 export declare function buildAgentSession(deps: BuildAgentSessionDeps): AgentSession;
 export declare function buildSharedDeps(a: {
@@ -43,4 +44,5 @@ export declare function buildSharedDeps(a: {
     effectiveCwd: string | undefined;
     maxTurns: string;
     initialPermissionMode: PermissionMode | undefined;
+    explicitProvider?: string;
 }): BuildAgentSessionDeps;

package/dist/cli/commands/provider-xai-login.d.ts

@@ -0,0 +1,16 @@
+export interface XaiLoginResult {
+    ok: boolean;
+    message: string;
+    last4?: string;
+}
+export declare function runXaiDeviceCodeLogin(opts: {
+    onStatus?: (line: string) => void;
+    timeoutMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<XaiLoginResult>;
+export declare function runXaiBrowserLogin(opts: {
+    onStatus?: (line: string) => void;
+    openBrowser?: (url: string) => void;
+    timeoutMs?: number;
+}): Promise<XaiLoginResult>;
+export declare function runXaiLogout(): XaiLoginResult;

package/dist/cli/commands/provider.d.ts

@@ -1,9 +1,17 @@
 import { Command } from 'commander';
 import { type OpenAIAuthSource, type AuthResolverDeps } from '../../agent/providers/openai-compatible/auth.js';
+import { type XaiAuthSource, type XaiAuthResolverDeps } from '../../agent/providers/xai/auth.js';
 export declare function buildProviderAuthDiagnose(explicitConfigKey: string | undefined, deps?: AuthResolverDeps): {
     source: OpenAIAuthSource;
     message: string;
     exitCode: number;
     last4?: string;
 };
+export declare function buildXaiAuthDiagnose(explicitConfigKey: string | undefined, forceMode?: 'apikey' | 'oauth', deps?: XaiAuthResolverDeps): {
+    source: XaiAuthSource;
+    message: string;
+    exitCode: number;
+    last4?: string;
+    mode?: string;
+};
 export declare function registerProviderCommand(program: Command): void;

package/dist/cli/shared-helpers.d.ts

@@ -1,3 +1,4 @@
+import { type ProviderRouteHints } from '../agent/providers/index.js';
 import type { AgentModelInput, ThinkingConfig, EffortLevel } from '../agent/types.js';
 import type { GrantManager } from './slash/commands/allow-dir.js';
 export { composeSystemPrompt, loadConfigSystemPrompt, loadSystemPrompt, OPERATOR_CONFIG_HEADER, resolveBaseSystemPrompt, } from './system-prompt.js';
@@ -5,7 +6,8 @@ export { parseProvider } from './provider-parser.js';
 export type { ParseProviderOptions } from './provider-parser.js';
 export declare function getApiKey(): string | undefined;
 export declare function getCodexApiKey(): string | undefined;
-export declare function getApiKeyForModel(model: string | undefined): string | undefined;
+export declare function getApiKeyForModel(model: string | undefined, hints?: ProviderRouteHints): string | undefined;
+export declare function explicitProviderHints(provider: string | undefined): ProviderRouteHints | undefined;
 export declare function getModel(): AgentModelInput;
 export declare function getDefaultSubagentModel(parentModel?: AgentModelInput): AgentModelInput;
 export declare function parseThinking(raw: string | undefined): ThinkingConfig | undefined;