@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/coding-agent/core/provider-composer.js

@@ -0,0 +1,422 @@
+import { andorraLazyStream, } from "../../ai/index.js";
+import { andorraGetApiProvider } from "../../ai/compat.js";
+import { andorraClearConfigValueCache, andorraGetConfigValueEnvVarNames, andorraIsCommandConfigValue, andorraIsConfigValueConfigured, andorraResolveConfigValueOrThrow, andorraResolveHeadersOrThrow, } from "./resolve-config-value.js";
+export const clearApiKeyCache = andorraClearConfigValueCache;
+function andorraMergeCompat(base, override) {
+    if (!override)
+        return base;
+    const merged = { ...base, ...override };
+    const baseNested = base;
+    const overrideNested = override;
+    const mergedNested = merged;
+    for (const key of ["openRouterRouting", "vercelGatewayRouting", "chatTemplateKwargs", "chatTemplateArgs"]) {
+        const baseValue = baseNested?.[key];
+        const overrideValue = overrideNested[key];
+        if ((typeof baseValue === "object" && baseValue !== null) ||
+            (typeof overrideValue === "object" && overrideValue !== null)) {
+            mergedNested[key] = { ...baseValue, ...overrideValue };
+        }
+    }
+    return merged;
+}
+function andorraMergeInputLimits(base, override) {
+    if (!override)
+        return base;
+    return {
+        ...base,
+        ...override,
+        images: override.images
+            ? {
+                ...base?.images,
+                ...override.images,
+                resize: override.images.resize
+                    ? { ...base?.images?.resize, ...override.images.resize }
+                    : base?.images?.resize,
+            }
+            : base?.images,
+    };
+}
+function andorraApplyModelOverride(model, override) {
+    return {
+        ...model,
+        name: override.name ?? model.name,
+        reasoning: override.reasoning ?? model.reasoning,
+        thinkingLevelMap: override.thinkingLevelMap
+            ? { ...model.thinkingLevelMap, ...override.thinkingLevelMap }
+            : model.thinkingLevelMap,
+        input: override.input ?? model.input,
+        inputLimits: andorraMergeInputLimits(model.inputLimits, override.inputLimits),
+        cost: override.cost
+            ? {
+                input: override.cost.input ?? model.cost.input,
+                output: override.cost.output ?? model.cost.output,
+                cacheRead: override.cost.cacheRead ?? model.cost.cacheRead,
+                cacheWrite: override.cost.cacheWrite ?? model.cost.cacheWrite,
+                tiers: override.cost.tiers ?? model.cost.tiers,
+            }
+            : model.cost,
+        promptCache: override.promptCache ? { ...model.promptCache, ...override.promptCache } : model.promptCache,
+        contextWindow: override.contextWindow ?? model.contextWindow,
+        maxTokens: override.maxTokens ?? model.maxTokens,
+        samplingParams: override.samplingParams
+            ? { ...model.samplingParams, ...override.samplingParams }
+            : model.samplingParams,
+        compat: andorraMergeCompat(model.compat, override.compat),
+    };
+}
+function andorraModelFromJson(providerId, definition, providerConfig, defaults) {
+    const api = definition.api ?? providerConfig.api ?? defaults?.api;
+    if (!api) {
+        throw new Error(`Provider ${providerId}, model ${definition.id}: no "api" specified. Set at provider or model level.`);
+    }
+    const baseUrl = definition.baseUrl ?? providerConfig.baseUrl ?? defaults?.baseUrl;
+    if (!baseUrl)
+        throw new Error(`Provider ${providerId}: "baseUrl" is required when defining custom models.`);
+    if (definition.contextWindow !== undefined && definition.contextWindow <= 0) {
+        throw new Error(`Provider ${providerId}, model ${definition.id}: invalid contextWindow`);
+    }
+    if (definition.maxTokens !== undefined && definition.maxTokens <= 0) {
+        throw new Error(`Provider ${providerId}, model ${definition.id}: invalid maxTokens`);
+    }
+    return {
+        id: definition.id,
+        name: definition.name ?? definition.id,
+        api: api,
+        provider: providerId,
+        baseUrl,
+        reasoning: definition.reasoning ?? false,
+        thinkingLevelMap: definition.thinkingLevelMap,
+        input: (definition.input ?? ["text"]),
+        inputLimits: definition.inputLimits,
+        cost: definition.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        promptCache: definition.promptCache,
+        contextWindow: definition.contextWindow ?? 128000,
+        maxTokens: definition.maxTokens ?? 16384,
+        samplingParams: definition.samplingParams,
+        headers: undefined,
+        compat: andorraMergeCompat(providerConfig.compat, definition.compat),
+    };
+}
+function andorraFindModelDefaults(models, modelId, api) {
+    return (models.find((model) => model.id === modelId) ??
+        (api ? models.find((model) => model.api === api) : undefined) ??
+        models.find((model) => model.api === "openai-completions") ??
+        models[0]);
+}
+function andorraApplyModelsJson(providerId, baseModels, config) {
+    if (!config)
+        return [...baseModels];
+    if (config.oauth && !config.baseUrl) {
+        throw new Error(`Provider ${providerId}: "baseUrl" is required when "oauth" is set.`);
+    }
+    const hasOverrides = config.modelOverrides && Object.keys(config.modelOverrides).length > 0;
+    if (!config.models?.length &&
+        !config.baseUrl &&
+        !config.headers &&
+        !config.compat &&
+        !hasOverrides &&
+        !config.apiKey &&
+        !config.oauth &&
+        config.authHeader === undefined) {
+        throw new Error(`Provider ${providerId}: must specify "baseUrl", "headers", "compat", "modelOverrides", or "models".`);
+    }
+    const models = baseModels.map((model) => ({
+        ...model,
+        baseUrl: config.oauth === "radius" ? model.baseUrl : (config.baseUrl ?? model.baseUrl),
+        compat: andorraMergeCompat(model.compat, config.compat),
+    }));
+    for (const definition of config.models ?? []) {
+        const existingIndex = models.findIndex((model) => model.id === definition.id);
+        const defaults = andorraFindModelDefaults(models, definition.id, definition.api ?? config.api);
+        const model = andorraModelFromJson(providerId, definition, config, defaults);
+        if (existingIndex >= 0)
+            models[existingIndex] = model;
+        else
+            models.push(model);
+    }
+    return models;
+}
+function andorraApplyExtension(providerId, models, config) {
+    if (!config)
+        return [...models];
+    if (!config.models) {
+        return config.baseUrl ? models.map((model) => ({ ...model, baseUrl: config.baseUrl })) : [...models];
+    }
+    return config.models.map((definition) => {
+        const defaults = andorraFindModelDefaults(models, definition.id, definition.api ?? config.api);
+        const api = definition.api ?? config.api ?? defaults?.api;
+        if (!api) {
+            throw new Error(`Provider ${providerId}, model ${definition.id}: no "api" specified. Set at provider or model level.`);
+        }
+        const baseUrl = definition.baseUrl ?? config.baseUrl ?? defaults?.baseUrl;
+        if (!baseUrl)
+            throw new Error(`Provider ${providerId}: "baseUrl" is required when defining custom models.`);
+        return {
+            ...definition,
+            api,
+            provider: providerId,
+            baseUrl,
+            headers: undefined,
+        };
+    });
+}
+function andorraAdaptOAuth(config) {
+    return {
+        name: config.name,
+        isSubscription: config.isSubscription,
+        login: async (callbacks) => {
+            const credential = await config.login({
+                onAuth: (info) => callbacks.notify({ type: "auth_url", ...info }),
+                onDeviceCode: (info) => callbacks.notify({ type: "device_code", ...info }),
+                onPrompt: (prompt) => callbacks.prompt({ type: "text", ...prompt }),
+                onProgress: (message) => callbacks.notify({ type: "progress", message }),
+                onManualCodeInput: () => callbacks.prompt({ type: "manual_code", message: "Paste the authorization code" }),
+                onSelect: (prompt) => callbacks.prompt({ type: "select", ...prompt }),
+                signal: callbacks.signal,
+            });
+            return { ...credential, type: "oauth" };
+        },
+        refresh: async (credential, signal) => ({ ...(await config.refreshToken(credential, signal)), type: "oauth" }),
+        toAuth: async (credential) => ({ apiKey: config.getApiKey(credential) }),
+    };
+}
+function andorraWithConfiguredAuth(auth, headers, authHeader) {
+    let mergedHeaders = auth.headers || headers ? { ...auth.headers, ...headers } : undefined;
+    if (authHeader) {
+        if (!auth.apiKey)
+            throw new Error("authHeader requires a resolved API key");
+        mergedHeaders = { ...mergedHeaders, Authorization: `Bearer ${auth.apiKey}` };
+    }
+    return { ...auth, headers: mergedHeaders };
+}
+function andorraConfiguredApiKey(config, extension) {
+    return extension?.apiKey ?? config?.apiKey;
+}
+function andorraConfiguredHeaders(config, extension) {
+    if (!config?.headers && !extension?.headers)
+        return undefined;
+    return { ...config?.headers, ...extension?.headers };
+}
+async function andorraConfigContextEnv(values, ctx, explicit) {
+    const env = { ...explicit };
+    for (const name of new Set(values.flatMap(andorraGetConfigValueEnvVarNames))) {
+        if (env[name] !== undefined)
+            continue;
+        const value = await ctx.env(name);
+        if (value !== undefined)
+            env[name] = value;
+    }
+    return Object.keys(env).length > 0 ? env : undefined;
+}
+function andorraComposeApiKeyAuth(providerId, base, config, extension) {
+    const inherited = base?.auth.apiKey;
+    const rawKey = andorraConfiguredApiKey(config, extension);
+    const oauth = extension?.oauth ?? base?.auth.oauth;
+    // OAuth-only providers get no fabricated API-key login method.
+    if (!inherited && rawKey === undefined && oauth)
+        return undefined;
+    const rawHeaders = andorraConfiguredHeaders(config, extension);
+    const authHeader = extension?.authHeader ?? config?.authHeader ?? false;
+    return {
+        name: inherited?.name ?? "API key",
+        login: inherited?.login ??
+            (async (interaction) => ({
+                type: "api_key",
+                key: await interaction.prompt({ type: "secret", message: "Enter API key" }),
+            })),
+        check: async (input) => {
+            if (input.credential) {
+                if (inherited?.check)
+                    return inherited.check(input);
+                if (input.credential.key)
+                    return { type: "api_key", source: "stored credential" };
+                const resolved = await inherited?.resolve(input);
+                return resolved ? { type: "api_key", source: resolved.source } : undefined;
+            }
+            if (rawKey !== undefined) {
+                if (andorraIsCommandConfigValue(rawKey))
+                    return { type: "api_key", source: "configured API key" };
+                const envNames = andorraGetConfigValueEnvVarNames(rawKey);
+                for (const name of envNames) {
+                    if ((await input.ctx.env(name)) === undefined)
+                        return undefined;
+                }
+                return { type: "api_key", source: "configured API key" };
+            }
+            if (inherited?.check)
+                return inherited.check(input);
+            const resolved = await inherited?.resolve(input);
+            return resolved ? { type: "api_key", source: resolved.source } : undefined;
+        },
+        resolve: async (input) => {
+            let result;
+            if (input.credential) {
+                result = inherited
+                    ? await inherited.resolve(input)
+                    : input.credential.key
+                        ? { auth: { apiKey: input.credential.key }, env: input.credential.env, source: "stored credential" }
+                        : undefined;
+            }
+            else if (rawKey !== undefined) {
+                const env = await andorraConfigContextEnv([rawKey], input.ctx);
+                const key = andorraResolveConfigValueOrThrow(rawKey, `API key for provider "${providerId}"`, env);
+                result = inherited
+                    ? await inherited.resolve({ ...input, credential: { type: "api_key", key } })
+                    : { auth: { apiKey: key }, source: "configured API key" };
+            }
+            else {
+                result = await inherited?.resolve(input);
+            }
+            if (!result)
+                return undefined;
+            const explicitEnv = { ...(input.credential?.env ?? {}), ...(result.env ?? {}) };
+            const headerEnv = await andorraConfigContextEnv(Object.values(rawHeaders ?? {}), input.ctx, explicitEnv);
+            const headers = andorraResolveHeadersOrThrow(rawHeaders, `provider "${providerId}"`, headerEnv);
+            return { ...result, auth: andorraWithConfiguredAuth(result.auth, headers, authHeader) };
+        },
+    };
+}
+function andorraComposeOAuthAuth(providerId, base, config, extension) {
+    const oauth = extension?.oauth ? andorraAdaptOAuth(extension.oauth) : base?.auth.oauth;
+    if (!oauth)
+        return undefined;
+    const rawHeaders = andorraConfiguredHeaders(config, extension);
+    const authHeader = extension?.authHeader ?? config?.authHeader ?? false;
+    return {
+        ...oauth,
+        toAuth: async (credential) => {
+            const auth = await oauth.toAuth(credential);
+            const env = credential.env;
+            const headers = andorraResolveHeadersOrThrow(rawHeaders, `provider "${providerId}"`, typeof env === "object" && env !== null ? env : undefined);
+            return andorraWithConfiguredAuth(auth, headers, authHeader);
+        },
+    };
+}
+function andorraRawModelHeaders(model, config, extension) {
+    const definition = config?.models?.find((entry) => entry.id === model.id);
+    const extensionModel = extension?.models?.find((entry) => entry.id === model.id);
+    const headers = {
+        ...config?.modelOverrides?.[model.id]?.headers,
+        ...definition?.headers,
+        ...extensionModel?.headers,
+    };
+    return Object.keys(headers).length > 0 ? headers : undefined;
+}
+export function andorraValidateExtensionProvider(providerId, base, modelsConfig, extension) {
+    if (extension.streamSimple && !extension.api) {
+        throw new Error(`Provider ${providerId}: "api" is required when registering streamSimple.`);
+    }
+    andorraApplyExtension(providerId, andorraApplyModelsJson(providerId, base?.getModels() ?? [], modelsConfig), extension);
+}
+/** Compose built-in, models.json, and extension layers without reading credentials. */
+export function andorraComposeModelProvider(providerId, base, modelConfig, extension) {
+    const config = modelConfig.getProvider(providerId);
+    let extensionOAuthCredential;
+    let refreshedExtensionModels;
+    const andorraCurrentExtension = () => extension && refreshedExtensionModels ? { ...extension, models: refreshedExtensionModels } : extension;
+    // models.json modelOverrides are the topmost user-config layer: they apply once,
+    // after custom-model upserts, extension model replacement, and legacy OAuth projection.
+    const andorraGetModels = () => {
+        let models = andorraApplyExtension(providerId, andorraApplyModelsJson(providerId, base?.getModels() ?? [], config), andorraCurrentExtension());
+        if (extensionOAuthCredential && extension?.oauth?.modifyModels) {
+            models = extension.oauth.modifyModels(models, extensionOAuthCredential);
+        }
+        return models.map((model) => {
+            const override = config?.modelOverrides?.[model.id];
+            return override ? andorraApplyModelOverride(model, override) : model;
+        });
+    };
+    // Validate eagerly so registration/reload reports structural errors immediately.
+    andorraGetModels();
+    const apiKey = andorraComposeApiKeyAuth(providerId, base, config, extension);
+    const oauth = andorraComposeOAuthAuth(providerId, base, config, extension);
+    if (!apiKey && !oauth)
+        throw new Error(`Provider ${providerId}: no authentication method configured.`);
+    const andorraSupportsBaseApi = (model) => base?.getModels().some((entry) => entry.api === model.api) ?? false;
+    const andorraStreamWith = (model, context, options, simple) => andorraLazyStream(model, async () => {
+        if (extension?.streamSimple && model.api === extension.api) {
+            return extension.streamSimple(model, context, options);
+        }
+        if (base && andorraSupportsBaseApi(model)) {
+            return simple
+                ? base.streamSimple(model, context, options)
+                : base.stream(model, context, options);
+        }
+        const api = andorraGetApiProvider(model.api);
+        if (!api)
+            throw new Error(`No API provider registered for api: ${model.api}`);
+        return simple
+            ? api.streamSimple(model, context, options)
+            : api.stream(model, context, options);
+    });
+    const provider = {
+        id: providerId,
+        name: extension?.name ?? config?.name ?? base?.name ?? extension?.oauth?.name ?? providerId,
+        baseUrl: extension?.baseUrl ?? config?.baseUrl ?? base?.baseUrl,
+        headers: base?.headers,
+        auth: { ...(apiKey ? { apiKey } : {}), ...(oauth ? { oauth } : {}) },
+        getModels: andorraGetModels,
+        refreshModels: base?.refreshModels || extension?.refreshModels || extension?.oauth?.modifyModels
+            ? async (context) => {
+                await base?.refreshModels?.(context);
+                let refreshed;
+                if (extension?.refreshModels)
+                    refreshed = await extension.refreshModels(context);
+                if (context.signal.aborted)
+                    return;
+                const oauthCredential = context.credential?.type === "oauth" ? context.credential : undefined;
+                await context.publish({
+                    update: () => {
+                        if (refreshed) {
+                            // Validate before publishing the new synchronous list.
+                            andorraApplyExtension(providerId, andorraApplyModelsJson(providerId, base?.getModels() ?? [], config), {
+                                ...extension,
+                                models: refreshed,
+                            });
+                            refreshedExtensionModels = refreshed;
+                        }
+                        extensionOAuthCredential = oauthCredential;
+                    },
+                });
+            }
+            : undefined,
+        filterModels: base?.filterModels
+            ? (models, credential) => base.filterModels(models, credential)
+            : undefined,
+        stream: (model, context, options) => andorraStreamWith(model, context, options, false),
+        streamSimple: (model, context, options) => andorraStreamWith(model, context, options, true),
+    };
+    const fetchDeferred = base?.fetchDeferred;
+    if (fetchDeferred) {
+        provider.fetchDeferred = (model, handle, options) => fetchDeferred(model, handle, options);
+    }
+    const cancelDeferred = base?.cancelDeferred;
+    if (cancelDeferred) {
+        provider.cancelDeferred = (model, handle, options) => cancelDeferred(model, handle, options);
+    }
+    return provider;
+}
+export function andorraResolveConfiguredModelHeaders(model, config, extension, env) {
+    return andorraResolveHeadersOrThrow(andorraRawModelHeaders(model, config, extension), `model "${model.provider}/${model.id}"`, env);
+}
+export function andorraResolveCompatibilityRequestConfig(model, config, extension) {
+    const configured = andorraResolveHeadersOrThrow({ ...andorraConfiguredHeaders(config, extension), ...andorraRawModelHeaders(model, config, extension) }, `model "${model.provider}/${model.id}"`);
+    return {
+        headers: model.headers || configured ? { ...model.headers, ...configured } : undefined,
+        authHeader: extension?.authHeader ?? config?.authHeader ?? false,
+    };
+}
+export function andorraConfiguredRequestAuthStatus(config, extension) {
+    const value = andorraConfiguredApiKey(config, extension);
+    if (value === undefined)
+        return undefined;
+    if (andorraIsCommandConfigValue(value))
+        return { configured: true, source: "models_json_command" };
+    const names = andorraGetConfigValueEnvVarNames(value);
+    if (names.length > 0) {
+        return andorraIsConfigValueConfigured(value)
+            ? { configured: true, source: "environment", label: names.join(", ") }
+            : { configured: false };
+    }
+    return { configured: true, source: extension?.apiKey !== undefined ? "fallback" : "models_json_key" };
+}

package/dist/vendor/engine/runtime/coding-agent/core/radius.d.ts

@@ -0,0 +1,4 @@
+export declare const RADIUS_PROVIDER_ID = "radius";
+export declare const ENV_RADIUS_GATEWAY = "ANDORRA_ENGINE_RADIUS_GATEWAY";
+/** Radius gateway origin, honoring the `ANDORRA_ENGINE_RADIUS_GATEWAY` override. */
+export declare function andorraGetRadiusGatewayUrl(): string;

package/dist/vendor/engine/runtime/coding-agent/core/radius.js

@@ -0,0 +1,7 @@
+import { DEFAULT_RADIUS_GATEWAY, andorraNormalizeRadiusGatewayUrl } from "../../ai/providers/radius-config.js";
+export const RADIUS_PROVIDER_ID = "radius";
+export const ENV_RADIUS_GATEWAY = "ANDORRA_ENGINE_RADIUS_GATEWAY";
+/** Radius gateway origin, honoring the `ANDORRA_ENGINE_RADIUS_GATEWAY` override. */
+export function andorraGetRadiusGatewayUrl() {
+    return andorraNormalizeRadiusGatewayUrl(process.env[ENV_RADIUS_GATEWAY] ?? DEFAULT_RADIUS_GATEWAY);
+}

package/dist/vendor/engine/runtime/coding-agent/core/remote-catalog-provider.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../../ai/index.js";
+export declare const REMOTE_CATALOG_REFRESH_INTERVAL_MS: number;
+/** Add a persisted pi.dev catalog overlay to a static built-in provider. */
+export declare function andorraWithRemoteCatalog(provider: Provider, catalogBaseUrl?: string, localGeneratedAt?: number): Provider;

package/dist/vendor/engine/runtime/coding-agent/core/remote-catalog-provider.js

@@ -0,0 +1,121 @@
+import { VERSION } from "../config.js";
+import { andorraFetchWithRetry } from "../utils/management-http.js";
+import { andorraGetAndorraUserAgent } from "../utils/pi-user-agent.js";
+const DEFAULT_CATALOG_BASE_URL = "https://pi.dev";
+const REMOTE_CATALOG_ATTEMPT_TIMEOUT_MS = 4_000;
+export const REMOTE_CATALOG_REFRESH_INTERVAL_MS = 4 * 60 * 60 * 1000;
+function andorraMergeModels(baseline, dynamic) {
+    const merged = [...baseline];
+    for (const model of dynamic) {
+        const index = merged.findIndex((entry) => entry.id === model.id);
+        if (index >= 0)
+            merged[index] = model;
+        else
+            merged.push(model);
+    }
+    return merged;
+}
+function andorraParseCatalog(providerId, value) {
+    const entries = Array.isArray(value)
+        ? value
+        : typeof value === "object" && value !== null && "models" in value && Array.isArray(value.models)
+            ? value.models
+            : typeof value === "object" && value !== null
+                ? Object.values(value)
+                : undefined;
+    if (!entries)
+        throw new Error(`Invalid model catalog for provider "${providerId}"`);
+    return entries
+        .filter((entry) => typeof entry === "object" && entry !== null && "id" in entry)
+        .map((model) => ({ ...model, provider: providerId }));
+}
+function andorraRemoteModels(entry, localGeneratedAt) {
+    if (!entry)
+        return [];
+    if (localGeneratedAt !== undefined && (entry.lastModified === undefined || entry.lastModified <= localGeneratedAt)) {
+        return [];
+    }
+    return entry.models;
+}
+/** Add a persisted pi.dev catalog overlay to a static built-in provider. */
+export function andorraWithRemoteCatalog(provider, catalogBaseUrl = DEFAULT_CATALOG_BASE_URL, localGeneratedAt) {
+    let dynamicModels = [];
+    return {
+        ...provider,
+        getModels: () => andorraMergeModels(provider.getModels(), dynamicModels),
+        refreshModels: async (context) => {
+            const stored = context.stored;
+            const restored = andorraRemoteModels(stored, localGeneratedAt).filter((model) => model.provider === provider.id);
+            if (!(await context.publish({
+                update: () => {
+                    dynamicModels = restored;
+                },
+            }))) {
+                return;
+            }
+            if (!context.allowNetwork || context.signal.aborted)
+                return;
+            if (!context.force &&
+                stored?.checkedAt !== undefined &&
+                stored.lastModified !== undefined &&
+                Date.now() - stored.checkedAt < REMOTE_CATALOG_REFRESH_INTERVAL_MS) {
+                return;
+            }
+            // Only revalidate when a cached body backs the validator, so a 304 can never
+            // leave the overlay empty.
+            const validator = stored?.models.length ? stored.etag : undefined;
+            const url = new URL(`/api/models/providers/${encodeURIComponent(provider.id)}`, catalogBaseUrl);
+            const response = await andorraFetchWithRetry(url, {
+                headers: {
+                    accept: "application/json",
+                    "User-Agent": andorraGetAndorraUserAgent(VERSION),
+                    ...(validator ? { "if-none-match": validator } : {}),
+                },
+                signal: context.signal,
+            }, { attemptTimeoutMs: REMOTE_CATALOG_ATTEMPT_TIMEOUT_MS });
+            if (context.signal.aborted)
+                return;
+            const checkedAt = Date.now();
+            // Unchanged: dynamicModels already holds the stored overlay, so only the
+            // freshness window moves.
+            if (response.status === 304 && stored) {
+                await context.publish({ persist: { ...stored, checkedAt } });
+                return;
+            }
+            if (response.status === 404 || response.status === 501) {
+                await context.publish({
+                    persist: {
+                        ...(stored ?? { models: [] }),
+                        checkedAt,
+                        lastModified: 0,
+                        etag: undefined,
+                    },
+                });
+                return;
+            }
+            if (!response.ok) {
+                // Transient failure: the cached body and its validator stay valid, so keep the
+                // etag and let the next refresh revalidate instead of downloading the catalog.
+                await context.publish({ persist: { ...(stored ?? { models: [] }), checkedAt } });
+                throw new Error(`Model catalog request failed for ${provider.id}: ${response.status}`);
+            }
+            const refreshed = andorraParseCatalog(provider.id, await response.json());
+            const lastModified = Date.parse(response.headers.get("last-modified") ?? "");
+            if (context.signal.aborted)
+                return;
+            const entry = {
+                models: refreshed,
+                checkedAt,
+                lastModified: Number.isNaN(lastModified) ? 0 : lastModified,
+                etag: response.headers.get("etag") ?? undefined,
+            };
+            const published = andorraRemoteModels(entry, localGeneratedAt);
+            await context.publish({
+                persist: entry,
+                update: () => {
+                    dynamicModels = published;
+                },
+            });
+        },
+    };
+}

package/dist/vendor/engine/runtime/coding-agent/core/resolve-config-value.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Resolve configuration values that may be shell commands, environment variables, or literals.
+ * Used by auth-storage.ts and model-registry.ts.
+ */
+export declare function andorraGetConfigValueEnvVarName(config: string): string | undefined;
+export declare function andorraGetConfigValueEnvVarNames(config: string): string[];
+export declare function andorraGetMissingConfigValueEnvVarNames(config: string, env?: Record<string, string>): string[];
+export declare function andorraIsCommandConfigValue(config: string): boolean;
+export declare function andorraIsConfigValueConfigured(config: string, env?: Record<string, string>): boolean;
+/**
+ * Resolve a config value (API key, header value, etc.) to an actual value.
+ * - If starts with "!", executes the rest as a shell command and uses stdout (cached)
+ * - Interpolates "$ENV_VAR" or "${ENV_VAR}" references with the named environment variable
+ * - In non-command values, "$$" escapes a literal "$" and "$!" escapes a literal "!"
+ * - Otherwise treats the value as a literal
+ */
+export declare function andorraResolveConfigValue(config: string, env?: Record<string, string>): string | undefined;
+/**
+ * Resolve all header values using the same resolution logic as API keys.
+ */
+export declare function andorraResolveConfigValueUncached(config: string, env?: Record<string, string>): string | undefined;
+export declare function andorraResolveConfigValueOrThrow(config: string, description: string, env?: Record<string, string>): string;
+/**
+ * Resolve all header values using the same resolution logic as API keys.
+ */
+export declare function andorraResolveHeaders(headers: Record<string, string> | undefined, env?: Record<string, string>): Record<string, string> | undefined;
+export declare function andorraResolveHeadersOrThrow(headers: Record<string, string> | undefined, description: string, env?: Record<string, string>): Record<string, string> | undefined;
+/** Clear the config value command cache. Exported for testing. */
+export declare function andorraClearConfigValueCache(): void;