@agent-native/core 0.203.1-nightly-20261007154213 → 0.203.1

package/dist/provider-api/actions/provider-api.d.ts

@@ -311,8 +311,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
+        provider?: undefined;
         id?: undefined;
-        deleted?: undefined;
         found?: undefined;
         providers: {
             id: string;
@@ -324,46 +324,46 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
-        provider?: undefined;
+        deleted?: undefined;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
     } | {
         id?: undefined;
-        deleted?: undefined;
         count?: undefined;
         providers?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
+        deleted?: undefined;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
     } | {
-        deleted?: undefined;
+        provider?: undefined;
         count?: undefined;
         providers?: undefined;
-        provider?: undefined;
         found: boolean;
         id: string;
+        deleted?: undefined;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
     } | {
+        provider?: undefined;
         count?: undefined;
         found?: undefined;
         providers?: undefined;
-        provider?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
     } | {
-        deleted?: undefined;
+        provider?: undefined;
         count?: undefined;
         found?: undefined;
         providers?: undefined;
-        provider?: undefined;
+        deleted?: undefined;
         registered: boolean;
         id: string;
         label: string;

package/dist/resources/handlers.d.ts

@@ -39,8 +39,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
     error: string;
 }>;
 export declare function handleDeleteResource(event: any): Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/resources/store.js

@@ -2,6 +2,7 @@ import crypto from "crypto";
 import { getDbExec } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
+import { noteJobFrontmatterWrite } from "../jobs/frontmatter-loss.js";
 import { canUseLocalWorkspaceResourcePath, deleteLocalWorkspaceResource, deleteLocalWorkspaceResourceIfCurrent, isLocalWorkspaceResourceId, isLocalWorkspaceResourcesEnabled, listLocalWorkspaceResources, localWorkspaceResourcePathFromId, readLocalWorkspaceResource, writeLocalWorkspaceResourceIfAbsentAtPath, writeLocalWorkspaceResourceIfCurrent, writeLocalWorkspaceResource, } from "../local-artifacts/index.js";
 import { getRequestOrgId, getRequestUserEmail, } from "../server/request-context.js";
 import { getSetting, putSetting, } from "../settings/store.js";
@@ -1164,8 +1165,9 @@ export async function resourcePut(owner, path, content, mimeType, options) {
     const now = Date.now();
     const size = Buffer.byteLength(content, "utf8");
     const mime = mimeType || "text/markdown";
+    const isJobFile = path.startsWith("jobs/");
     const { rows: existing } = await client.execute({
-        sql: `SELECT id, created_at, created_by, visibility, thread_id, run_id, expires_at, metadata FROM resources WHERE owner = ? AND path = ?`,
+        sql: `SELECT id, created_at, created_by, visibility, thread_id, run_id, expires_at, metadata${isJobFile ? ", content" : ""} FROM resources WHERE owner = ? AND path = ?`,
         args: [owner, path],
     });
     const existingRow = existing[0];
@@ -1215,6 +1217,16 @@ export async function resourcePut(owner, path, content, mimeType, options) {
             metadata,
         ],
     });
+    if (typeof existingRow?.content === "string") {
+        await noteJobFrontmatterWrite({
+            owner,
+            orgId: organizationIdFromResourceOwner(owner),
+            path,
+            before: existingRow.content,
+            after: content,
+            writer: "resourcePut",
+        });
+    }
     emitResourceChange(id, path, owner, options?.requestSource);
     return {
         id,
@@ -1344,6 +1356,14 @@ export async function resourcePutIfCurrent(input) {
     if (rows.length === 0)
         return null;
     const resource = rowToResource(rows[0]);
+    await noteJobFrontmatterWrite({
+        owner: resource.owner,
+        orgId: organizationIdFromResourceOwner(resource.owner),
+        path: resource.path,
+        before: input.expectedContent,
+        after: resource.content,
+        writer: "resourcePutIfCurrent",
+    });
     emitResourceChange(resource.id, resource.path, resource.owner);
     return resource;
 }
@@ -1453,6 +1473,14 @@ async function resourcePutIfSnapshotInternal(input, emitChange, clientOverride)
         return null;
     const resource = rowToResource(rows[0]);
     if (emitChange) {
+        await noteJobFrontmatterWrite({
+            owner: resource.owner,
+            orgId: organizationIdFromResourceOwner(resource.owner),
+            path: resource.path,
+            before: previous.content,
+            after: resource.content,
+            writer: "resourcePutIfSnapshot",
+        });
         emitResourceChange(resource.id, resource.path, resource.owner, input.options?.requestSource);
     }
     return { before: previous, resource };
@@ -1490,7 +1518,17 @@ export async function resourcePutSnapshotBatchIfCurrent(writes, options) {
             return null;
         throw error;
     }
-    for (const [index, { resource }] of result.entries()) {
+    for (const [index, { before, resource }] of result.entries()) {
+        if (before) {
+            await noteJobFrontmatterWrite({
+                owner: resource.owner,
+                orgId: organizationIdFromResourceOwner(resource.owner),
+                path: resource.path,
+                before: before.content,
+                after: resource.content,
+                writer: "resourcePutSnapshotBatchIfCurrent",
+            });
+        }
         emitResourceChange(resource.id, resource.path, resource.owner, writes[index]?.options?.requestSource);
     }
     return result;

package/dist/scripts/agent-engines/list-agent-engines.js

@@ -134,11 +134,14 @@ export async function run(args = {}) {
             detectedFromUser ??
             detectedFromEnv ??
             getAgentEngineEntry("anthropic"));
-    const currentModelCandidate = appDefaultUsable && currentEntry?.name === appDefault?.engine
-        ? appDefault?.model
-        : storedUsable && currentEntry?.name === current?.engine
-            ? current?.model
-            : undefined;
+    const configuredModel = getAppConfig().agent.model;
+    const currentModelCandidate = configuredModel && configuredModel !== "auto"
+        ? configuredModel
+        : appDefaultUsable && currentEntry?.name === appDefault?.engine
+            ? appDefault?.model
+            : storedUsable && currentEntry?.name === current?.engine
+                ? current?.model
+                : undefined;
     const acceptsCustomModels = currentEntry
         ? await resolveEngineAcceptsCustomModels(currentEntry)
         : false;

package/dist/scripts/agent-engines/manage-agent-engine.js

@@ -2,12 +2,13 @@ import { canUpdateAgentAppModelDefaultSettings, normalizeAgentAppModelDefaultApp
 import { CHATGPT_SUBSCRIPTION_ENGINE_NAME } from "../../agent/chatgpt-subscription-contract.js";
 import { listChatGPTSubscriptionModels } from "../../agent/engine/chatgpt-subscription-engine.js";
 import { getAgentEngineEntry, isAgentEnginePackageInstalled, normalizeModelForEngine, resolveEngineAcceptsCustomModels, resolveEnginePreservesCustomModels, registerBuiltinEngines, } from "../../agent/engine/index.js";
+import { defaultModelMessagesForUser } from "../../localization/default-model-messages.js";
 import { getRequestOrgId, getRequestUserEmail, } from "../../server/request-context.js";
 import { run as runList } from "./list-agent-engines.js";
-import { run as runSet } from "./set-agent-engine.js";
+import { run as runSet, resolveDefaultModelEffective, effectiveConfigurationMessage, } from "./set-agent-engine.js";
 import { run as runTest } from "./test-agent-engine.js";
 export const tool = {
-    description: 'Manage AI agent engines: list available engines, set the organization default engine/model, test an engine, or manage the current app/template default model. Pass action="list" to see options, action="set" to change the organization default (owners and admins only; list reports canUpdateDefault), action="test" to verify connectivity, action="get-app-default" to inspect this app default, action="set-app-default" to set this app default, or action="reset-app-default" to clear it.',
+    description: 'Manage AI engines and scoped defaults. Clarify organization/personal versus app when the user says "change my default" without a scope. action="set" changes only the organization default (owners/admins) or a no-organization user\'s personal default, preserving ALL app overrides. action="set-app-default" changes only the named app default, preserving explicit chat/automation models. Only an explicit request to inherit uses action="reset-app-default". action="list" shows available options, effective selection and canUpdateDefault; action="get-app-default" inspects the app default; action="test" checks connectivity.',
     parameters: {
         type: "object",
         properties: {
@@ -113,6 +114,10 @@ async function runSetAppDefault(args) {
             ? "Error: Only organization owners and admins can change app model defaults."
             : "Error: Authentication required to change app model defaults.";
     }
+    const effective = await resolveDefaultModelEffective(ctx, appId, {
+        appDefault: { engine, model: normalizedModel },
+    });
+    const messages = await defaultModelMessagesForUser(ctx.userEmail);
     const settings = await writeAgentAppModelDefaultSettings(ctx, appId, {
         engine,
         model: normalizedModel,
@@ -123,8 +128,12 @@ async function runSetAppDefault(args) {
         : ` Requested model "${model}" is no longer supported, so "${normalizedModel}" was saved instead.`;
     return JSON.stringify({
         ok: true,
+        requestedScope: "app",
         ...settings,
-        message: `Default model for ${appId} set to ${normalizedModel} via ${entry.label}.${normalizedNote}`,
+        effective,
+        preservedOverrides: ["chat-models", "automation-models"],
+        message: `Default model for ${appId} set to ${normalizedModel} via ${entry.label}.${normalizedNote}` +
+            effectiveConfigurationMessage(effective, messages),
     }, null, 2);
 }
 async function runResetAppDefault(args) {
@@ -138,11 +147,20 @@ async function runResetAppDefault(args) {
             ? "Error: Only organization owners and admins can reset app model defaults."
             : "Error: Authentication required to reset app model defaults.";
     }
+    registerBuiltinEngines();
+    const effective = await resolveDefaultModelEffective(ctx, appId, {
+        appDefault: null,
+    });
+    const messages = await defaultModelMessagesForUser(ctx.userEmail);
     const settings = await resetAgentAppModelDefaultSettings(ctx, appId);
     return JSON.stringify({
         ok: true,
+        requestedScope: "app",
         ...settings,
-        message: `Default model for ${appId} reset to the global LLM default.`,
+        effective,
+        preservedOverrides: ["chat-models", "automation-models"],
+        message: `Default model for ${appId} reset to the global LLM default.` +
+            effectiveConfigurationMessage(effective, messages),
     }, null, 2);
 }
 export async function run(args, context) {

package/dist/scripts/agent-engines/set-agent-engine.d.ts

@@ -4,6 +4,7 @@
  */
 import { type ActionRunContext } from "../../action.js";
 import { type DefaultAgentEngineChangeMeta, type DefaultAgentEngineContext } from "../../agent/default-agent-engine.js";
+import { type AgentEngineStatusResult } from "../../agent/engine-status.js";
 import type { ActionTool } from "../../agent/types.js";
 export declare const tool: ActionTool;
 export declare const DEFAULT_MODEL_ADMIN_REQUIRED_ERROR_CODE = "default_model_admin_required";
@@ -13,6 +14,11 @@ export type SelectDefaultAgentEngineResult = {
     model: string;
     requestedModel: string;
     label: string;
+    scope: "org" | "user";
+    appId?: string;
+    effective: Pick<AgentEngineStatusResult, "configured" | "engine" | "model"> & {
+        source?: "configuration" | "app-default" | "org" | "user" | "legacy" | "app_secrets" | "env";
+    };
 } | {
     status: "refused";
     message: string;
@@ -26,6 +32,24 @@ export type SelectDefaultAgentEngineResult = {
     status: "unavailable";
     message: string;
 };
+export declare function resolveDefaultModelEffective(ctx: DefaultAgentEngineContext, appId: string | null, planned?: {
+    sharedDefault?: {
+        engine: string;
+        model: string;
+    };
+    appDefault?: {
+        engine: string;
+        model: string;
+    } | null;
+}): Promise<Extract<SelectDefaultAgentEngineResult, {
+    status: "selected";
+}>["effective"]>;
+export declare function effectiveConfigurationMessage(effective: Extract<SelectDefaultAgentEngineResult, {
+    status: "selected";
+}>["effective"], messages: {
+    configurationOverride: string;
+    configurationUnavailable: string;
+}): string;
 /**
  * Validate an engine/model pair and save it as the default for the caller's
  * scope. Shared by the `set` action and the provider-key save route so both
@@ -34,5 +58,6 @@ export type SelectDefaultAgentEngineResult = {
 export declare function selectDefaultAgentEngine(input: {
     engine?: string;
     model?: string;
+    appId?: string;
 }, meta: DefaultAgentEngineChangeMeta, ctx?: DefaultAgentEngineContext): Promise<SelectDefaultAgentEngineResult>;
 export declare function run(args: Record<string, string>, context?: ActionRunContext): Promise<string>;

package/dist/scripts/agent-engines/set-agent-engine.js

@@ -3,15 +3,19 @@
  * `agent-engine` setting) for the caller's organization.
  */
 import { ActionContractError } from "../../action.js";
+import { normalizeAgentAppModelDefaultAppId, readAgentAppModelDefaultSettings, } from "../../agent/app-model-defaults.js";
 import { CHATGPT_SUBSCRIPTION_ENGINE_NAME } from "../../agent/chatgpt-subscription-contract.js";
-import { recordDefaultAgentEngineRefusal, resolveDefaultAgentEngineAuthority, writeDefaultAgentEngineSelection, } from "../../agent/default-agent-engine.js";
+import { recordDefaultAgentEngineRefusal, readDefaultAgentEngineSettingDetailed, resolveDefaultAgentEngineAuthority, writeDefaultAgentEngineSelection, } from "../../agent/default-agent-engine.js";
+import { resolveAgentEngineStatus, } from "../../agent/engine-status.js";
 import { listChatGPTSubscriptionModels } from "../../agent/engine/chatgpt-subscription-engine.js";
-import { listAgentEngines, getAgentEngineEntry, isAgentEnginePackageInstalled, isStoredEngineUsableForRequest, normalizeModelForEngine, resolveEngineAcceptsCustomModels, resolveEnginePreservesCustomModels, registerBuiltinEngines, } from "../../agent/engine/index.js";
+import { listAgentEngines, detectEngineFromEnv, detectEngineFromUserSecrets, getAgentEngineEntry, isAgentEnginePackageInstalled, isStoredEngineUsableForRequest, normalizeModelForEngine, resolveEngineAcceptsCustomModels, resolveEnginePreservesCustomModels, registerBuiltinEngines, } from "../../agent/engine/index.js";
+import { getAppConfig } from "../../app-config/index.js";
 import { CHATGPT_SUBSCRIPTION_LAB } from "../../labs/core-labs.js";
 import { getUserLabEnabled } from "../../labs/store.js";
+import { defaultModelMessagesForUser } from "../../localization/default-model-messages.js";
 import { getRequestOrgId, getRequestUserEmail, } from "../../server/request-context.js";
 export const tool = {
-    description: 'Set the organization\'s default AI engine and model. Only organization owners and admins can change it; a user with no organization sets their own. Changes take effect on the next conversation. Use manage-agent-engine with action="list" first to see available options and whether you can change the default (canUpdateDefault).',
+    description: 'Set only the organization\'s default AI engine and model (or a no-organization user\'s personal default). Preserve every app override and explicit chat/automation model. For an app default, use manage-agent-engine with action="set-app-default"; inheritance requires action="reset-app-default". If the user\'s requested scope is ambiguous, clarify organization/personal versus app before changing anything. The result separates the saved default from the current app\'s effective model. Only organization owners and admins can change it. Use manage-agent-engine with action="list" first to see options and canUpdateDefault.',
     parameters: {
         type: "object",
         properties: {
@@ -28,6 +32,58 @@ export const tool = {
     },
 };
 export const DEFAULT_MODEL_ADMIN_REQUIRED_ERROR_CODE = "default_model_admin_required";
+export async function resolveDefaultModelEffective(ctx, appId, planned = {}) {
+    const credentialIdentity = ctx.userEmail
+        ? { userEmail: ctx.userEmail, orgId: ctx.orgId }
+        : undefined;
+    const shared = {
+        source: ctx.orgId ? "org" : "user",
+    };
+    const status = await resolveAgentEngineStatus({
+        lookupEntry: getAgentEngineEntry,
+        readStoredEngine: async () => {
+            if (planned.sharedDefault)
+                return planned.sharedDefault;
+            const stored = await readDefaultAgentEngineSettingDetailed(ctx);
+            shared.source = stored.source;
+            return stored.value;
+        },
+        readAppDefault: async () => {
+            if (planned.appDefault !== undefined)
+                return planned.appDefault;
+            if (!appId)
+                return null;
+            const stored = await readAgentAppModelDefaultSettings(ctx, appId);
+            return stored.engine && stored.model
+                ? { engine: stored.engine, model: stored.model }
+                : null;
+        },
+        readOpenAiBaseUrlConfigured: () => false,
+        isStoredEngineUsable: (stored, entry) => isStoredEngineUsableForRequest(stored, entry, { credentialIdentity }),
+        detectFromUserSecrets: () => detectEngineFromUserSecrets(credentialIdentity),
+        detectFromEnv: detectEngineFromEnv,
+    });
+    return {
+        configured: status.configured,
+        engine: status.engine,
+        model: status.model,
+        source: status.selectionSource === "shared-default"
+            ? shared.source === "none"
+                ? undefined
+                : shared.source
+            : status.selectionSource,
+    };
+}
+export function effectiveConfigurationMessage(effective, messages) {
+    if (effective.source !== "configuration")
+        return "";
+    return (" " +
+        (effective.configured
+            ? messages.configurationOverride
+                .replace("{{model}}", effective.model)
+                .replace("{{engine}}", effective.engine)
+            : messages.configurationUnavailable));
+}
 /**
  * Validate an engine/model pair and save it as the default for the caller's
  * scope. Shared by the `set` action and the provider-key save route so both
@@ -135,6 +191,15 @@ export async function selectDefaultAgentEngine(input, meta, ctx = {
         acceptsCustomModels,
         preserveCustomModels,
     });
+    const config = getAppConfig();
+    const appIdInput = input.appId ?? config.app.id ?? config.app.template ?? config.app.slug;
+    const appId = normalizeAgentAppModelDefaultAppId(appIdInput);
+    if (appIdInput && !appId) {
+        return { status: "invalid", message: "A valid appId is required." };
+    }
+    const effective = await resolveDefaultModelEffective(ctx, appId, {
+        sharedDefault: { engine: engineName, model: resolvedModel },
+    });
     await writeDefaultAgentEngineSelection(authority, { engine: engineName, model: resolvedModel }, meta);
     return {
         status: "selected",
@@ -142,10 +207,14 @@ export async function selectDefaultAgentEngine(input, meta, ctx = {
         model: resolvedModel,
         requestedModel,
         label: entry.label,
+        scope: authority.scope,
+        effective,
+        ...(appId ? { appId } : {}),
     };
 }
 export async function run(args, context) {
-    const result = await selectDefaultAgentEngine(args, {
+    const messages = await defaultModelMessagesForUser(getRequestUserEmail());
+    const result = await selectDefaultAgentEngine({ ...args, appId: context?.appId ?? args.appId }, {
         actionName: context?.actionName ?? "manage-agent-engine",
         caller: context?.caller,
         threadId: context?.threadId,
@@ -166,13 +235,30 @@ export async function run(args, context) {
     if (result.status === "unavailable") {
         return `Error: ${result.message}`;
     }
-    const normalizedNote = result.model === result.requestedModel
-        ? ""
-        : ` Requested model "${result.requestedModel}" is no longer supported, so "${result.model}" was saved instead.`;
     return JSON.stringify({
         ok: true,
         engine: result.engine,
         model: result.model,
-        message: `Default model set to ${result.label} with model ${result.model}. Takes effect on the next conversation.${normalizedNote}`,
+        requestedModel: result.requestedModel,
+        scope: result.scope,
+        requestedScope: result.scope,
+        appId: result.appId,
+        appDefaultReset: false,
+        preservedOverrides: ["app-models", "chat-models", "automation-models"],
+        effective: result.effective,
+        message: (result.scope === "org"
+            ? messages.organizationSelected
+            : messages.userSelected)
+            .replace("{{model}}", result.model)
+            .replace("{{engine}}", result.label) +
+            (result.effective.source === "configuration"
+                ? effectiveConfigurationMessage(result.effective, messages)
+                : result.appId && result.effective.source === "app-default"
+                    ? " " +
+                        messages.appOverridePreserved
+                            .replace("{{appId}}", result.appId)
+                            .replace("{{model}}", result.effective.model)
+                            .replace("{{engine}}", result.effective.engine)
+                    : ""),
     });
 }

package/dist/secrets/routes.d.ts

@@ -73,32 +73,32 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     ok?: undefined;
     status?: undefined;
 } | {
+    error?: undefined;
     errorCode?: undefined;
     retryable?: undefined;
     ok: boolean;
     status: string;
-    error?: undefined;
 } | {
     ok?: undefined;
     error: string;
     removed?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     ok?: undefined;
     error: string;
     note?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note?: undefined;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note: string;
-    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -126,11 +126,11 @@ export declare function createAdHocSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;

package/dist/server/agent-engine-default-model-route.d.ts

@@ -9,8 +9,8 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    ok?: undefined;
     scope?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     error: any;

package/dist/server/agent-engine-ollama-models-route.d.ts

@@ -1,6 +1,6 @@
 export declare function createAgentEngineOllamaModelsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
     models?: undefined;
 } | {
     error?: undefined;

package/dist/server/core-routes-plugin.d.ts

@@ -1,5 +1,6 @@
 import type { H3Event } from "h3";
 import type { CredentialFixer } from "../agent/engine/credential-state.js";
+export { normalizeAgentEngineStatusModel, resolveAgentEngineStatus, type AgentEngineStatusResult, type AgentEngineStatusResponse, type AgentEngineStatusDeps, } from "../agent/engine-status.js";
 import { type AppStateAnonymousOwnerResolver } from "../application-state/handlers.js";
 import { type DatabaseSchemaHealthResult } from "../db/runtime-diagnostics.js";
 import { ensureS3FileUploadProvider } from "../file-upload/s3.js";
@@ -23,49 +24,6 @@ import { type H3AppShim } from "./framework-request-handler.js";
 export declare const FRAMEWORK_ROUTE_PREFIX = "/_agent-native";
 export declare const FRAMEWORK_EVENTS_ROUTE = "/_agent-native/events";
 export declare const LEGACY_FRAMEWORK_EVENTS_ROUTE = "/_agent-native/poll-events";
-export declare function normalizeAgentEngineStatusModel(entry: {
-    name: string;
-    defaultModel: string;
-    supportedModels: readonly string[];
-} | undefined, model: string | null | undefined): string;
-type AgentEngineStatusEntry = {
-    name: string;
-    defaultModel: string;
-    supportedModels: readonly string[];
-    requiredEnvVars: readonly string[];
-};
-export interface AgentEngineStatusResult {
-    configured: boolean;
-    engine?: string;
-    model?: string;
-    source?: "settings" | "env" | "app_secrets";
-    envVar?: string;
-    openAiBaseUrlConfigured?: boolean;
-}
-export interface AgentEngineStatusResponse extends AgentEngineStatusResult {
-    /** Strict chat-only eligibility; distinct from broad engine `configured`. */
-    chatEligible: boolean;
-}
-export interface AgentEngineStatusDeps<E extends AgentEngineStatusEntry = AgentEngineStatusEntry> {
-    readStoredEngine: () => Promise<{
-        engine?: string;
-        model?: string;
-    } | null>;
-    readOpenAiBaseUrlConfigured: () => boolean | Promise<boolean>;
-    isStoredEngineUsable: (stored: unknown, entry: E) => boolean | Promise<boolean>;
-    detectFromUserSecrets: () => Promise<E | null>;
-    detectFromEnv: () => E | null | Promise<E | null>;
-    lookupEntry?: (engine: string) => E | undefined;
-}
-/**
- * Resolve "does this request have a usable AI provider" for one identity.
- *
- * Every call site pays for these lookups on a user-visible path (the agent
- * composer blocks on the status probe), so the two identity-independent reads
- * start together and the expensive `app_secrets` sweep only runs when the
- * cheaper sources have not already answered.
- */
-export declare function resolveAgentEngineStatus<E extends AgentEngineStatusEntry>(deps: AgentEngineStatusDeps<E>): Promise<AgentEngineStatusResult>;
 /**
  * Resolve the identity the status answer depends on. Both lookups memoize per
  * request inside their own helpers, so repeating them here stays cheap.