@happyvertical/smrt-config 0.53.2 → 0.53.4

package/AGENTS.md

@@ -22,6 +22,7 @@ Configuration management with cosmiconfig, secret sanitization, and SSG export.
 | `sanitizeConfig(config)` | Strips keys matching: apiKey, password, secret, token, credential, private, auth, key |
 | `resolveApplicationRuntime(config)` | Resolve and validate a local, self-hosted, or cloud infrastructure profile |
 | `resolveConfiguredApplicationRuntime()` | Resolve loaded file config plus highest-priority `setConfig()` runtime overrides |
+| `resolveConfiguredAIProvider()` / `tryResolveAIProviderConfig()` | One AI provider resolver (`src/ai.ts`): explicit > `ai` block > `SMRT_AI_*`/`HAVE_AI_*` env > selected provider's key var > auto-detect; see README |
 | `getApplicationRuntimePreset(profile)` | Inspect a profile's safe provider defaults |
 
 ## Key Files
@@ -34,6 +35,7 @@ Configuration management with cosmiconfig, secret sanitization, and SSG export.
 
 ## Gotchas
 
+- **AI credentials are bound to their source's provider**: a lower-priority key/baseUrl is dropped when another provider wins; redacted base URLs show only the origin. **AI keys come from the environment**: the `ai` block names a variable (`apiKeyEnv`); resolver errors/`toJSON()` never contain keys or URL credentials. Core and the chat dev routes use this resolver; agents share its provider key-name map (`getDefaultAIKeyEnvName`) and keep per-tenant secret lookup; do not add new provider-env parsing elsewhere.
 - **clearCache() is global**: affects all modules sharing the config instance
 - **SSG export defaults to no secrets**: must explicitly set `includeSecrets: true` to include them
 - **Deep merge**: later values override earlier ones at each key level

package/README.md

@@ -169,6 +169,56 @@ const safeJson = exportConfig(config, { includeSecrets: false });
 const sanitized = sanitizeConfig(config);
 ```
 
+## AI provider
+
+Declare the assistant model once in `smrt.config.ts`; keep the secret in the environment.
+
+```ts
+export default defineConfig({
+  ai: { provider: 'openai', model: 'gpt-4o', apiKeyEnv: 'OPENAI_API_KEY' },
+});
+```
+
+```ts
+import { resolveConfiguredAIProvider, toAIClientOptions } from '@happyvertical/smrt-config';
+import { getAI } from '@happyvertical/ai';
+
+const ai = await getAI(toAIClientOptions(resolveConfiguredAIProvider()));
+```
+
+Default precedence, applied per field (`provider`, `apiKey`, `baseUrl`, `model`), highest first:
+
+1. `explicit` values passed by the caller (for example a class's `options.ai`)
+2. the `ai` block (`provider`, `model`, `baseUrl`, `apiKeyEnv`; legacy `packages.ai` is read below `ai`)
+3. environment, one prefix at a time: `<PREFIX>_PROVIDER`, `_API_KEY`, `_BASE_URL`, `_MODEL` for `SMRT_AI`, then `HAVE_AI`
+4. the selected provider's own key variable (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`); a key for any other provider is never used
+5. with no provider selected, auto-detect the first provider whose key variable is set (openai, anthropic, gemini)
+
+Credential binding: a key or base URL belongs to the provider named by its own source (explicit, the
+`ai` block, or one env prefix). If a higher-priority source selects a different provider, the lower
+source's key and base URL are discarded and the key comes only from sources valid for the selected
+provider (then that provider's own key variable). A source that supplies a key but names no provider is
+generic and binds to whichever provider is selected. Displayed base URLs (`toJSON()`,
+`describeAIProviderConfig()`, `redactBaseUrl()`) expose only the origin; the real URL still goes to the client.
+The rule holds at every layer: the `ai` block layers (runtime `ai`, runtime `packages.ai`, file `ai`, file `packages.ai`)
+are merged with provider ownership (`mergeAIConfigLayers`): when a higher layer names a different provider, the lower
+layers' `apiKey`, `apiKeyEnv`, `baseUrl` and `model` are dropped (a model id is provider-specific). A layer with no provider
+binds to the provider selected so far. Core applies the same rule between its global `ai` config and `options.ai`, and always
+builds its client from the resolver's bound result. Aliases are normalised before coalescing (`provider`/`type`,
+`model`/`defaultModel`), so a blank primary never hides the alias.
+All object merges go through one canonicalising helper, `mergeAIConfigObjects(lower, higher)`
+(folds `provider`/`type` and `model`/`defaultModel`, drops blanks, and drops the lower side's provider, key, key variable, base URL and model
+when the higher side names a different provider): accumulating `setConfig({ ai })` / `setConfig({ packages: { ai } })`, `mergeExportedConfig`
+`ai` blocks, and core's global `ai` + `options.ai`. `withAIAliases()` sets both client-facing aliases on the final result.
+Core consults the block only when it names a `provider`; a partial block behaves like no block.
+
+Call sites keep their historical order through options: the chat dev routes pass
+`prefixes: ['SMRT_CHAT_DEV', 'SMRT_AI', 'HAVE_AI']` and `envOverridesConfig: true`; core passes
+`prefixes: ['SMRT_AI']`, `autoDetect: false`. `resolveAIProviderConfig` throws
+`AIProviderNotConfiguredError` (naming variables only) when nothing is configured;
+`tryResolveAIProviderConfig` returns `undefined`. Results redact the key in `toJSON()` /
+`describeAIProviderConfig()`; errors never include key or URL credentials.
+
 ## API
 
 ### Functions
@@ -190,6 +240,10 @@ const sanitized = sanitizeConfig(config);
 | `getApplicationRuntimePreset(profile)` | Inspect an immutable copy of a profile preset |
 | `mergeExportedConfig(baseConfig, exportedConfig)` | Merge an exported config over a base |
 | `parseExportedConfig(raw)` | Parse an exported config string |
+| `resolveAIProviderConfig(options?)` / `tryResolveAIProviderConfig(options?)` | Pure resolver (throws / returns `undefined` when unconfigured) |
+| `resolveConfiguredAIProvider(options?)` / `tryResolveConfiguredAIProvider(options?)` | Same, against the loaded `ai` block |
+| `getAIConfigBlock()` | Effective `ai` block (runtime > file; `ai` > `packages.ai`) |
+| `toAIClientOptions(resolved)` | `getAI()` options (`type`, `provider`, `apiKey`, `baseUrl`, `defaultModel`) |
 
 ### Priority Order
 

package/dist/ai.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Shared AI provider resolution (#3372).
+ *
+ * One resolver for every AI consumer. Default precedence, highest first, applied
+ * per field (`provider`, `apiKey`, `baseUrl`, `model`):
+ *
+ * 1. `explicit` — values the caller passes in (for example `options.ai`).
+ * 2. The `ai` block of `smrt.config.ts` (`apiKeyEnv` names the key variable).
+ * 3. Environment variables, one prefix at a time, in `prefixes` order:
+ *    `<PREFIX>_PROVIDER`, `<PREFIX>_API_KEY`, `<PREFIX>_BASE_URL`,
+ *    `<PREFIX>_MODEL`. Default prefixes: `SMRT_AI`, then `HAVE_AI`.
+ * 4. Provider-specific key variable for the *selected* provider only
+ *    (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`).
+ * 5. Auto-detect: with no provider selected, the first provider whose key
+ *    variable is set (openai, anthropic, gemini).
+ *
+ * `envOverridesConfig` swaps (2) and (3) for call sites that historically let
+ * env win.
+ *
+ * Credential binding: a key or base URL is bound to the provider named by its
+ * own source (explicit, the config block, or one env prefix). When a
+ * higher-priority source selects a different provider, the lower source's key
+ * and base URL are discarded, then the selected provider's own key variable is
+ * used. A source that supplies a key but names no provider is generic and
+ * binds to whichever provider is selected.
+ *
+ * Redaction: displayed base URLs expose only the origin. Secrets are never included in errors, `toJSON()` or `describe`.
+ */
+import type { AIConfigBlock } from './types.js';
+/** Provider -> conventional API key variable. */
+export declare const AI_PROVIDER_KEY_ENV: Readonly<Record<string, string>>;
+/** Default env prefixes, highest priority first. */
+export declare const DEFAULT_AI_ENV_PREFIXES: readonly string[];
+/** Conventional key variable for a provider name, if it has one. */
+export declare function getDefaultAIKeyEnvName(provider: string | undefined | null): string | undefined;
+export type AIConfigField = 'provider' | 'apiKey' | 'baseUrl' | 'model';
+/** Where a field came from. Names only; never values. */
+export type AIConfigSource = 'explicit' | 'config' | `env:${string}` | 'provider-key-env' | 'auto-detect';
+export interface AIExplicitConfig {
+    provider?: string;
+    /** Alias of `provider` accepted for `AIClientOptions` compatibility. */
+    type?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    /** Alias of `model` accepted for `AIClientOptions` compatibility. */
+    defaultModel?: string;
+}
+export interface ResolveAIProviderOptions {
+    /** Caller-supplied values; highest priority. */
+    explicit?: AIExplicitConfig | null;
+    /**
+     * The `smrt.config.ts` `ai` block. Omit to use the loaded config (via
+     * `resolveConfiguredAIProvider`); pass `null` to ignore config entirely.
+     */
+    config?: AIConfigBlock | null;
+    /** Environment to read. Defaults to `process.env`. */
+    env?: Readonly<Record<string, string | undefined>>;
+    /** Env prefixes, highest priority first. Default `['SMRT_AI', 'HAVE_AI']`. */
+    prefixes?: readonly string[];
+    /**
+     * Fall back to the selected provider's own key variable (`OPENAI_API_KEY`...).
+     * Default `true`.
+     */
+    providerKeyEnvFallback?: boolean;
+    /** Auto-detect provider from well-known key variables. Default `true`. */
+    autoDetect?: boolean;
+    /** Let env prefixes beat the config block. Default `false`. */
+    envOverridesConfig?: boolean;
+    /**
+     * Treat "no provider" as unconfigured even when an API key is present.
+     * Default `true`; when `false`, a key alone is enough (`provider` stays
+     * undefined and the provider layer applies its own default).
+     */
+    requireProvider?: boolean;
+}
+export interface ResolvedAIProviderConfig {
+    provider?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    /** Which source supplied each field (names only). */
+    sources: Partial<Record<AIConfigField, AIConfigSource>>;
+    /** Redacted view: safe to log or serialize. */
+    toJSON(): Record<string, unknown>;
+}
+/** Options for `getAI` (from `@happyvertical/ai`). */
+export interface AIProviderClientOptions {
+    type?: string;
+    provider?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    defaultModel?: string;
+}
+/** Thrown when no provider is configured. The message names variables only. */
+export declare class AIProviderNotConfiguredError extends Error {
+    readonly code = "SMRT_AI_NOT_CONFIGURED";
+    constructor(message: string);
+}
+/**
+ * Reduce a base URL to its origin (scheme, host, port) for display. Userinfo,
+ * path, query and fragment can all carry credentials, so none are shown. The
+ * real URL is still what is passed to the client.
+ */
+export declare function redactBaseUrl(value: string | undefined): string | undefined;
+export declare function tryResolveAIProviderConfig(options?: ResolveAIProviderOptions): ResolvedAIProviderConfig | undefined;
+/** Resolve or throw {@link AIProviderNotConfiguredError}. */
+export declare function resolveAIProviderConfig(options?: ResolveAIProviderOptions): ResolvedAIProviderConfig;
+/** Redacted description: presence flags and source names, never secrets. */
+export declare function describeAIProviderConfig(resolved: Pick<ResolvedAIProviderConfig, 'provider' | 'apiKey' | 'baseUrl' | 'model' | 'sources'>): Record<string, unknown>;
+/** Convert a resolved config into `getAI()` options, omitting unset fields. */
+export declare function toAIClientOptions(resolved: Pick<ResolvedAIProviderConfig, 'provider' | 'apiKey' | 'baseUrl' | 'model'>): AIProviderClientOptions;
+/**
+ * Canonicalise one AI config object: blank strings are removed, `type` folds
+ * into `provider` and `defaultModel` into `model` (`provider`/`model` win when
+ * both are non-blank). Other keys pass through untouched.
+ */
+export declare function canonicalizeAIConfig(input: unknown): Record<string, unknown>;
+/**
+ * The one merge for two AI config objects (`lower` < `higher`). Both sides are
+ * canonicalised first. When `higher` names a provider and `lower` names a
+ * different one, `lower`'s provider, key, key variable, base URL and model are
+ * dropped so no credential is paired with another provider. Everything else is
+ * a shallow overlay with `higher` winning. The result carries canonical
+ * `provider` / `model` only; use {@link withAIAliases} for client-facing aliases.
+ */
+export declare function mergeAIConfigObjects(lower: unknown, higher: unknown): Record<string, unknown>;
+/** Set both client-facing aliases (`provider`+`type`, `model`+`defaultModel`). */
+export declare function withAIAliases<T extends Record<string, unknown>>(config: T): T;
+//# sourceMappingURL=ai.d.ts.map

package/dist/ai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../src/ai.ts"],"names":[],"mappings":"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"}

package/dist/export.d.ts

@@ -1,11 +1,3 @@
-/**
- * Config export utilities for static site generation
- *
- * These utilities enable exporting database-backed agent configurations
- * to static files for SSG sites.
- *
- * @module
- */
 /**
  * Deep-clone a config object, removing every key that looks like a secret.
  *

package/dist/export.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../src/export.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAqKH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAyCvD;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,OAAO,EACf,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAaR;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAY5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnE,UAAU,EAAE,CAAC,EACb,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC,GACzB,CAAC,CA6BH"}
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../src/export.ts"],"names":[],"mappings":"AA8KA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAyCvD;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,OAAO,EACf,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAaR;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAY5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnE,UAAU,EAAE,CAAC,EACb,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC,GACzB,CAAC,CA2CH"}

package/dist/index.d.ts

@@ -1,10 +1,12 @@
+import { type ResolveAIProviderOptions, type ResolvedAIProviderConfig } from './ai.js';
 import { type ResolvedApplicationRuntime } from './runtime-profile.js';
-import type { LoadConfigOptions, SmrtConfig } from './types.js';
+import type { AIConfigBlock, LoadConfigOptions, SmrtConfig } from './types.js';
+export { AI_PROVIDER_KEY_ENV, type AIConfigField, type AIConfigSource, type AIExplicitConfig, type AIProviderClientOptions, AIProviderNotConfiguredError, canonicalizeAIConfig, DEFAULT_AI_ENV_PREFIXES, describeAIProviderConfig, getDefaultAIKeyEnvName, mergeAIConfigObjects, type ResolveAIProviderOptions, type ResolvedAIProviderConfig, redactBaseUrl, resolveAIProviderConfig, toAIClientOptions, tryResolveAIProviderConfig, withAIAliases, } from './ai.js';
 export { type ExportConfigOptions, exportConfig, mergeExportedConfig, parseExportedConfig, sanitizeConfig, } from './export.js';
 export { clearRuntimeConfig, getRuntimeConfig, mergeConfigs } from './merge.js';
 export type { ApplicationRuntimeConfig, ApplicationRuntimeProfile, AssetOwnership, AssetStorageProvider, AuthenticationProvider, BackupProvider, ConnectionOwnership, DatabaseEngine, JobTopology, NetworkExposure, OwnerBootstrapMode, ResolvedApplicationRuntime, RuntimeAssetProvider, RuntimeAuthenticationProvider, RuntimeCapabilities, RuntimeDatabaseProvider, RuntimeInvariants, RuntimeJobProvider, RuntimeNetworkProvider, RuntimeOverrideReport, RuntimePortabilityProvider, RuntimeProfileValidationIssue, RuntimeProviderOverrides, RuntimeProviders, RuntimeSecretProvider, RuntimeTenancyProvider, SecretOwnership, SecretProvider, TenancyMode, TenantContextMode, TenantIsolation, } from './runtime-profile.js';
 export { getApplicationRuntimePreset, RuntimeProfileValidationError, resolveApplicationRuntime, } from './runtime-profile.js';
-export type { CliConfig, DatabaseConfig, ExportConfig, ExportFileConfig, ExportFilterValue, LoadConfigOptions, MigrationsConfig, MigrationsPostgresConfig, PostgresPermissionsConfig, SchemaContractConfig, SiteConfig, SiteLocation, SiteNavigation, SiteNavigationLink, SitePublisher, SiteTheme, SmrtConfig, SmrtGlobalConfig, } from './types.js';
+export type { AIConfigBlock, CliConfig, DatabaseConfig, ExportConfig, ExportFileConfig, ExportFilterValue, LoadConfigOptions, MigrationsConfig, MigrationsPostgresConfig, PostgresPermissionsConfig, SchemaContractConfig, SiteConfig, SiteLocation, SiteNavigation, SiteNavigationLink, SitePublisher, SiteTheme, SmrtConfig, SmrtGlobalConfig, } from './types.js';
 /**
  * Extend globalThis to include our config cache properties.
  * Using globalThis ensures all module instances share the same config,
@@ -251,4 +253,27 @@ export declare function clearCache(): void;
  * @see {@link loadConfig}
  */
 export declare function defineConfig(config: SmrtConfig): SmrtConfig;
+/**
+ * The effective `ai` block: runtime `ai` > runtime `packages.ai` > file `ai` >
+ * file `packages.ai` (`smrt init` historically wrote `packages.ai`), merged
+ * field by field. Returns `null` when none is declared.
+ */
+export declare function getAIConfigBlock(): AIConfigBlock | null;
+/**
+ * Merge `ai` block layers, lowest priority first, preserving provider
+ * ownership: `apiKey`, `apiKeyEnv`, `baseUrl` and `model` belong to the
+ * provider their layer names. When a higher layer names a different provider,
+ * the credentials and model already collected from lower layers for another
+ * provider are dropped (a model id is provider-specific, so it is dropped
+ * too). A layer that names no provider contributes generic values that bind to
+ * the provider selected so far.
+ */
+export declare function mergeAIConfigLayers(layers: ReadonlyArray<unknown>): AIConfigBlock | null;
+/**
+ * {@link resolveAIProviderConfig} against the loaded `smrt.config.ts` `ai`
+ * block. Throws `AIProviderNotConfiguredError` when nothing is configured.
+ */
+export declare function resolveConfiguredAIProvider(options?: ResolveAIProviderOptions): ResolvedAIProviderConfig;
+/** Non-throwing variant of {@link resolveConfiguredAIProvider}. */
+export declare function tryResolveConfiguredAIProvider(options?: ResolveAIProviderOptions): ResolvedAIProviderConfig | undefined;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -1,5 +1,221 @@
 import { cosmiconfig } from "cosmiconfig";
 import { createJiti } from "jiti";
+//#region src/ai.ts
+var AI_PROVIDER_KEY_ENV = Object.freeze({
+	openai: "OPENAI_API_KEY",
+	anthropic: "ANTHROPIC_API_KEY",
+	gemini: "GEMINI_API_KEY"
+});
+var AUTO_DETECT_ORDER = [
+	"openai",
+	"anthropic",
+	"gemini"
+];
+var DEFAULT_AI_ENV_PREFIXES = Object.freeze(["SMRT_AI", "HAVE_AI"]);
+function getDefaultAIKeyEnvName(provider) {
+	const normalized = nonEmpty(provider)?.toLowerCase();
+	return normalized && Object.hasOwn(AI_PROVIDER_KEY_ENV, normalized) ? AI_PROVIDER_KEY_ENV[normalized] : void 0;
+}
+var AIProviderNotConfiguredError = class extends Error {
+	code = "SMRT_AI_NOT_CONFIGURED";
+	constructor(message) {
+		super(message);
+		this.name = "AIProviderNotConfiguredError";
+	}
+};
+function nonEmpty(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function redactBaseUrl(value) {
+	if (!value) return void 0;
+	try {
+		const url = new URL(value);
+		return `${url.protocol}//${url.host}`;
+	} catch {
+		return "[unparseable-url]";
+	}
+}
+function tryResolveAIProviderConfig(options = {}) {
+	const env = options.env ?? process.env;
+	const read = (name) => nonEmpty(env[name]);
+	const prefixes = options.prefixes ?? DEFAULT_AI_ENV_PREFIXES;
+	const explicit = options.explicit ?? {};
+	const block = options.config ?? {};
+	const fromEnv = (suffix) => prefixes.map((prefix) => ({
+		source: `env:${prefix}_${suffix}`,
+		value: read(`${prefix}_${suffix}`)
+	}));
+	const explicitCand = (value) => ({
+		source: "explicit",
+		value: nonEmpty(value)
+	});
+	const configCand = (value) => ({
+		source: "config",
+		value: nonEmpty(value)
+	});
+	const layered = (exp, cfg, envs) => options.envOverridesConfig ? [
+		...exp,
+		...envs,
+		...cfg
+	] : [
+		...exp,
+		...cfg,
+		...envs
+	];
+	const first = (candidates) => {
+		for (const c of candidates) if (c.value) return {
+			value: c.value,
+			source: c.source
+		};
+	};
+	const sources = {};
+	const result = {};
+	const set = (field, hit) => {
+		if (hit) {
+			result[field] = hit.value;
+			sources[field] = hit.source;
+		}
+	};
+	set("provider", first(layered([explicitCand(nonEmpty(explicit.provider) ?? nonEmpty(explicit.type))], [configCand(block.provider)], fromEnv("PROVIDER"))));
+	set("model", first(layered([explicitCand(nonEmpty(explicit.model) ?? nonEmpty(explicit.defaultModel))], [configCand(block.model)], fromEnv("MODEL"))));
+	const autoDetected = result.provider || options.autoDetect === false ? void 0 : AUTO_DETECT_ORDER.find((p) => read(AI_PROVIDER_KEY_ENV[p]));
+	if (autoDetected) {
+		result.provider = autoDetected;
+		sources.provider = "auto-detect";
+	}
+	const selected = result.provider?.toLowerCase();
+	const configKeyEnv = nonEmpty(block.apiKeyEnv);
+	const explicitGroup = {
+		source: "explicit",
+		provider: nonEmpty(explicit.provider) ?? nonEmpty(explicit.type),
+		apiKey: nonEmpty(explicit.apiKey),
+		baseUrl: nonEmpty(explicit.baseUrl)
+	};
+	const configGroup = {
+		source: "config",
+		provider: nonEmpty(block.provider),
+		apiKey: nonEmpty(block.apiKey) ?? (configKeyEnv ? read(configKeyEnv) : void 0),
+		baseUrl: nonEmpty(block.baseUrl)
+	};
+	const envGroups = prefixes.map((prefix) => ({
+		source: `env:${prefix}`,
+		provider: read(`${prefix}_PROVIDER`),
+		apiKey: read(`${prefix}_API_KEY`),
+		baseUrl: read(`${prefix}_BASE_URL`)
+	}));
+	const groups = options.envOverridesConfig ? [
+		explicitGroup,
+		...envGroups,
+		configGroup
+	] : [
+		explicitGroup,
+		configGroup,
+		...envGroups
+	];
+	const usable = (g) => !g.provider || g.provider.toLowerCase() === selected;
+	const sourceName = (g, suffix) => g.source.startsWith("env:") ? `${g.source}_${suffix}` : g.source;
+	for (const g of groups) {
+		if (!usable(g)) continue;
+		if (g.baseUrl && !result.baseUrl) {
+			result.baseUrl = g.baseUrl;
+			sources.baseUrl = sourceName(g, "BASE_URL");
+		}
+		if (g.apiKey && !result.apiKey) {
+			result.apiKey = g.apiKey;
+			sources.apiKey = sourceName(g, "API_KEY");
+		}
+	}
+	const providerKeyEnv = getDefaultAIKeyEnvName(result.provider);
+	if (!result.apiKey && providerKeyEnv && options.providerKeyEnvFallback !== false && read(providerKeyEnv)) {
+		result.apiKey = read(providerKeyEnv);
+		sources.apiKey = "provider-key-env";
+	}
+	if (!result.provider && (options.requireProvider ?? true)) return;
+	if (!result.provider && !result.apiKey) return;
+	const resolved = {
+		...result,
+		sources,
+		toJSON: () => describeAIProviderConfig(resolved)
+	};
+	Object.defineProperty(resolved, "toJSON", { enumerable: false });
+	return resolved;
+}
+function resolveAIProviderConfig(options = {}) {
+	const resolved = tryResolveAIProviderConfig(options);
+	if (resolved) return resolved;
+	const envNames = (options.prefixes ?? DEFAULT_AI_ENV_PREFIXES).map((p) => `${p}_PROVIDER`).join(", ");
+	const keyNames = Object.values(AI_PROVIDER_KEY_ENV).join(", ");
+	throw new AIProviderNotConfiguredError(`No AI provider is configured. Set the \`ai\` block in smrt.config.ts (provider, model, apiKeyEnv), or set ${envNames}` + (options.autoDetect === false ? "." : `, or one of ${keyNames} to auto-detect the provider.`));
+}
+function describeAIProviderConfig(resolved) {
+	return {
+		provider: resolved.provider,
+		model: resolved.model,
+		baseUrl: redactBaseUrl(resolved.baseUrl),
+		apiKey: resolved.apiKey ? "[redacted]" : void 0,
+		sources: { ...resolved.sources }
+	};
+}
+function toAIClientOptions(resolved) {
+	const out = {};
+	if (resolved.provider) {
+		out.type = resolved.provider;
+		out.provider = resolved.provider;
+	}
+	if (resolved.apiKey) out.apiKey = resolved.apiKey;
+	if (resolved.baseUrl) out.baseUrl = resolved.baseUrl;
+	if (resolved.model) out.defaultModel = resolved.model;
+	return out;
+}
+var OWNED_AI_FIELDS = [
+	"apiKey",
+	"apiKeyEnv",
+	"baseUrl",
+	"model"
+];
+function canonicalizeAIConfig(input) {
+	if (!input || typeof input !== "object") return {};
+	const out = {};
+	for (const [key, value] of Object.entries(input)) {
+		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+		if (typeof value === "string" && value.trim().length === 0) continue;
+		out[key] = value;
+	}
+	const provider = nonEmpty(out.provider) ?? nonEmpty(out.type);
+	const model = nonEmpty(out.model) ?? nonEmpty(out.defaultModel);
+	delete out.type;
+	delete out.defaultModel;
+	if (provider) out.provider = provider;
+	else delete out.provider;
+	if (model) out.model = model;
+	else delete out.model;
+	return out;
+}
+function mergeAIConfigObjects(lower, higher) {
+	const low = canonicalizeAIConfig(lower);
+	const high = canonicalizeAIConfig(higher);
+	const lowName = nonEmpty(low.provider)?.toLowerCase();
+	const highName = nonEmpty(high.provider)?.toLowerCase();
+	if (lowName && highName && lowName !== highName) {
+		delete low.provider;
+		for (const f of OWNED_AI_FIELDS) delete low[f];
+	}
+	return {
+		...low,
+		...high
+	};
+}
+function withAIAliases(config) {
+	const out = { ...config };
+	const provider = nonEmpty(out.provider) ?? nonEmpty(out.type);
+	const model = nonEmpty(out.model) ?? nonEmpty(out.defaultModel);
+	for (const k of ["provider", "type"]) if (provider) out[k] = provider;
+	else delete out[k];
+	for (const k of ["model", "defaultModel"]) if (model) out[k] = model;
+	else delete out[k];
+	return out;
+}
+//#endregion
 //#region src/loader.ts
 var MODULE_NAME = "smrt";
 var jitiInstance;
@@ -581,7 +797,12 @@ function setConfig$1(config) {
 		const resetRuntime = current.runtime;
 		delete resetRuntime.providers;
 	}
-	globalThis.__smrtRuntimeConfig = deepMerge(current, config);
+	const merged = deepMerge(current, config);
+	const aiOf = (c) => isPlainObject(c) && isPlainObject(c.ai) ? c.ai : void 0;
+	const pkgAiOf = (c) => isPlainObject(c) && isPlainObject(c.packages) && isPlainObject(c.packages.ai) ? c.packages.ai : void 0;
+	if (aiOf(config)) merged.ai = mergeAIConfigObjects(aiOf(current) ?? {}, aiOf(config));
+	if (pkgAiOf(config)) merged.packages.ai = mergeAIConfigObjects(pkgAiOf(current) ?? {}, pkgAiOf(config));
+	globalThis.__smrtRuntimeConfig = merged;
 }
 function getRuntimeConfig() {
 	return globalThis.__smrtRuntimeConfig || {};
@@ -714,7 +935,8 @@ function mergeExportedConfig(baseConfig, exportedConfig) {
 	const result = { ...baseConfig };
 	for (const [key, value] of Object.entries(exportedConfig)) {
 		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
-		if (value !== null && typeof value === "object" && !Array.isArray(value) && result[key] !== null && typeof result[key] === "object" && !Array.isArray(result[key])) result[key] = mergeExportedConfig(result[key], value);
+		if (key === "ai" && value !== null && typeof value === "object" && !Array.isArray(value) && result[key] !== null && typeof result[key] === "object" && !Array.isArray(result[key])) result[key] = mergeAIConfigObjects(result[key], value);
+		else if (value !== null && typeof value === "object" && !Array.isArray(value) && result[key] !== null && typeof result[key] === "object" && !Array.isArray(result[key])) result[key] = mergeExportedConfig(result[key], value);
 		else result[key] = value;
 	}
 	return result;
@@ -783,7 +1005,65 @@ function clearCache() {
 function defineConfig(config) {
 	return config;
 }
+function getAIConfigBlock() {
+	const file = getLoadedConfig();
+	const runtime = getRuntimeConfig();
+	return mergeAIConfigLayers([
+		file?.packages?.ai,
+		file?.ai,
+		runtime.packages?.ai,
+		runtime.ai
+	]);
+}
+function mergeAIConfigLayers(layers) {
+	const FIELDS = [
+		"model",
+		"baseUrl",
+		"apiKeyEnv",
+		"apiKey"
+	];
+	let provider;
+	const values = {};
+	const owners = {};
+	const text = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+	for (const layer of layers) {
+		if (!layer || typeof layer !== "object") continue;
+		const rec = layer;
+		const named = text(rec.provider) ?? text(rec.type);
+		if (named && provider && named.toLowerCase() !== provider.toLowerCase()) for (const f of FIELDS) {
+			const owner = owners[f];
+			if (owner && owner.toLowerCase() !== named.toLowerCase()) {
+				delete values[f];
+				delete owners[f];
+			}
+		}
+		if (named) provider = named;
+		for (const f of FIELDS) {
+			const v = f === "model" ? text(rec.model) ?? text(rec.defaultModel) : text(rec[f]);
+			if (v) {
+				values[f] = v;
+				owners[f] = provider;
+			}
+		}
+	}
+	if (!provider && FIELDS.every((f) => !values[f])) return null;
+	const merged = { ...values };
+	if (provider) merged.provider = provider;
+	return merged;
+}
+function resolveConfiguredAIProvider(options = {}) {
+	return resolveAIProviderConfig({
+		...options,
+		config: options.config === void 0 ? getAIConfigBlock() : options.config
+	});
+}
+function tryResolveConfiguredAIProvider(options = {}) {
+	return tryResolveAIProviderConfig({
+		...options,
+		config: options.config === void 0 ? getAIConfigBlock() : options.config
+	});
+}
 //#endregion
-export { RuntimeProfileValidationError, clearCache, clearRuntimeConfig, defineConfig, exportConfig, getApplicationRuntimePreset, getConfig, getModuleConfig, getPackageConfig, getRuntimeConfig, getSiteConfig, loadConfig, mergeConfigs, mergeExportedConfig, parseExportedConfig, resolveApplicationRuntime, resolveConfiguredApplicationRuntime, sanitizeConfig, setConfig };
+export { AIProviderNotConfiguredError, AI_PROVIDER_KEY_ENV, DEFAULT_AI_ENV_PREFIXES, RuntimeProfileValidationError, canonicalizeAIConfig, clearCache, clearRuntimeConfig, defineConfig, describeAIProviderConfig, exportConfig, getAIConfigBlock, getApplicationRuntimePreset, getConfig, getDefaultAIKeyEnvName, getModuleConfig, getPackageConfig, getRuntimeConfig, getSiteConfig, loadConfig, mergeAIConfigLayers, mergeAIConfigObjects, mergeConfigs, mergeExportedConfig, parseExportedConfig, redactBaseUrl, resolveAIProviderConfig, resolveApplicationRuntime, resolveConfiguredAIProvider, resolveConfiguredApplicationRuntime, sanitizeConfig, setConfig, toAIClientOptions, tryResolveAIProviderConfig, tryResolveConfiguredAIProvider, withAIAliases };
 
 //# sourceMappingURL=index.js.map