@selesai/code 0.13.40 → 0.14.3

package/dist/core/provider-composer.d.ts

@@ -1,15 +1,50 @@
-import { type Api, type AssistantMessageEventStream, type Model, type OAuthCredentials, type OAuthLoginCallbacks, type Provider, type ProviderHeaders, type RefreshModelsContext, type SimpleStreamOptions, type TranscriptContext } from "@earendil-works/pi-ai";
+import { type AnyModel, type Api, type AssistantMessageEventStream, type ClassifierApi, type ImageApi, type Model, type OAuthCredentials, type OAuthLoginCallbacks, type Provider, type ProviderClassifier, type ProviderHeaders, type ProviderImages, type RefreshModelsContext, type SimpleStreamOptions, type TranscriptContext } from "@earendil-works/pi-ai";
 import type { ModelConfig, ModelsJsonProvider } from "./model-config.ts";
 import { clearConfigValueCache } from "./resolve-config-value.ts";
 export interface ExtensionOAuthConfig {
     name: string;
+    /** Whether access through this auth method is backed by a provider subscription. */
+    isSubscription?: boolean;
     /** @deprecated Retained for extension source compatibility; ignored by canonical auth flows. */
     usesCallbackServer?: boolean;
     login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
-    refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+    refreshToken(credentials: OAuthCredentials, signal: AbortSignal): Promise<OAuthCredentials>;
     getApiKey(credentials: OAuthCredentials): string;
     modifyModels?(models: Model<Api>[], credentials: OAuthCredentials): Model<Api>[];
 }
+interface ProviderModelConfigBase {
+    id: string;
+    name: string;
+    api?: string;
+    baseUrl?: string;
+    input: ("text" | "image")[];
+    inputLimits?: AnyModel["inputLimits"];
+    cost: AnyModel["cost"];
+    headers?: Record<string, string>;
+}
+export interface ProviderChatModelConfig extends ProviderModelConfigBase {
+    type?: "chat";
+    api?: Api;
+    reasoning: boolean;
+    thinkingLevelMap?: Model<Api>["thinkingLevelMap"];
+    promptCache?: Model<Api>["promptCache"];
+    contextWindow: number;
+    maxTokens: number;
+    samplingParams?: Model<Api>["samplingParams"];
+    samplingParamsByThinkingLevel?: Model<Api>["samplingParamsByThinkingLevel"];
+    compat?: Model<Api>["compat"];
+}
+export interface ProviderImageModelConfig extends ProviderModelConfigBase {
+    type: "image";
+    api?: ImageApi;
+    output: ("text" | "image")[];
+}
+export interface ProviderClassifierModelConfig extends ProviderModelConfigBase {
+    type: "classifier";
+    api?: ClassifierApi;
+    contextWindow: number;
+}
+export type ProviderModelConfig = ProviderChatModelConfig | ProviderImageModelConfig | ProviderClassifierModelConfig;
 /** Input type for the extension registerProvider API. */
 export interface ProviderConfigInput {
     name?: string;
@@ -22,24 +57,13 @@ export interface ProviderConfigInput {
      * sending and `options.onResponse` after receiving the response.
      */
     streamSimple?: (model: Model<Api>, context: TranscriptContext, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+    images?: Partial<Record<ImageApi, ProviderImages>>;
+    classifiers?: Partial<Record<ClassifierApi, ProviderClassifier>>;
     headers?: Record<string, string>;
     authHeader?: boolean;
     oauth?: ExtensionOAuthConfig;
-    models?: Array<{
-        id: string;
-        name: string;
-        api?: Api;
-        baseUrl?: string;
-        reasoning: boolean;
-        thinkingLevelMap?: Model<Api>["thinkingLevelMap"];
-        input: ("text" | "image")[];
-        cost: Model<Api>["cost"];
-        contextWindow: number;
-        maxTokens: number;
-        headers?: Record<string, string>;
-        compat?: Model<Api>["compat"];
-    }>;
-    refreshModels?(context: RefreshModelsContext): Promise<NonNullable<ProviderConfigInput["models"]>>;
+    models?: ProviderModelConfig[];
+    refreshModels?(context: RefreshModelsContext): Promise<ProviderModelConfig[]>;
 }
 export type AuthStatus = {
     configured: boolean;
@@ -50,10 +74,11 @@ export declare const clearApiKeyCache: typeof clearConfigValueCache;
 export declare function validateExtensionProvider(providerId: string, base: Provider | undefined, modelsConfig: ModelsJsonProvider | undefined, extension: ProviderConfigInput): void;
 /** Compose built-in, models.json, and extension layers without reading credentials. */
 export declare function composeModelProvider(providerId: string, base: Provider | undefined, modelConfig: ModelConfig, extension: ProviderConfigInput | undefined): Provider;
-export declare function resolveConfiguredModelHeaders(model: Model<Api>, config: ModelsJsonProvider | undefined, extension: ProviderConfigInput | undefined, env?: Record<string, string>): Record<string, string> | undefined;
+export declare function resolveConfiguredModelHeaders(model: AnyModel, config: ModelsJsonProvider | undefined, extension: ProviderConfigInput | undefined, env?: Record<string, string>): Record<string, string> | undefined;
 export interface CompatibilityRequestConfig {
     headers?: ProviderHeaders;
     authHeader: boolean;
 }
-export declare function resolveCompatibilityRequestConfig(model: Model<Api>, config: ModelsJsonProvider | undefined, extension: ProviderConfigInput | undefined): CompatibilityRequestConfig;
+export declare function resolveCompatibilityRequestConfig(model: AnyModel, config: ModelsJsonProvider | undefined, extension: ProviderConfigInput | undefined): CompatibilityRequestConfig;
 export declare function configuredRequestAuthStatus(config: ModelsJsonProvider | undefined, extension: ProviderConfigInput | undefined): AuthStatus | undefined;
+export {};

package/dist/core/provider-composer.js

@@ -1,6 +1,6 @@
-import { lazyStream, } from "@earendil-works/pi-ai";
-import { normalizeContext } from "@earendil-works/pi-ai/utils/transcript";
+import { isModelType, lazyStream, } from "@earendil-works/pi-ai";
 import { getApiProvider } from "@earendil-works/pi-ai/compat";
+import { classifierErrorResult, imageErrorResult } from "@earendil-works/pi-ai/utils/model-operations";
 import { clearConfigValueCache, getConfigValueEnvVarNames, isCommandConfigValue, isConfigValueConfigured, resolveConfigValueOrThrow, resolveHeadersOrThrow, } from "./resolve-config-value.js";
 export const clearApiKeyCache = clearConfigValueCache;
 /** Sane default when a model definition omits maxTokens (kept small so providers never reject it). */
@@ -14,6 +14,9 @@ function safeMaxTokens(value, contextWindow, fallback = DEFAULT_MAX_TOKENS) {
     const resolved = typeof value === "number" && value > 0 ? value : fallback;
     return Math.min(resolved, Math.max(contextWindow, 1));
 }
+function getAllProviderModels(provider) {
+    return provider ? (provider.getAllModels?.() ?? provider.getModels()) : [];
+}
 function mergeCompat(base, override) {
     if (!override)
         return base;
@@ -21,7 +24,7 @@ function mergeCompat(base, override) {
     const baseNested = base;
     const overrideNested = override;
     const mergedNested = merged;
-    for (const key of ["openRouterRouting", "vercelGatewayRouting", "chatTemplateKwargs"]) {
+    for (const key of ["openRouterRouting", "vercelGatewayRouting", "chatTemplateKwargs", "chatTemplateArgs"]) {
         const baseValue = baseNested?.[key];
         const overrideValue = overrideNested[key];
         if ((typeof baseValue === "object" && baseValue !== null) ||
@@ -31,6 +34,34 @@ function mergeCompat(base, override) {
     }
     return merged;
 }
+function mergeInputLimits(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 mergeSamplingParamsByThinkingLevel(base, override) {
+    if (!override)
+        return base;
+    const merged = { ...base };
+    for (const level of ["off", "minimal", "low", "medium", "high", "xhigh", "max"]) {
+        const params = override[level];
+        if (params)
+            merged[level] = { ...base?.[level], ...params };
+    }
+    return merged;
+}
 function applyModelOverride(model, override) {
     const contextWindow = override.contextWindow ?? model.contextWindow;
     return {
@@ -41,6 +72,7 @@ function applyModelOverride(model, override) {
             ? { ...model.thinkingLevelMap, ...override.thinkingLevelMap }
             : model.thinkingLevelMap,
         input: override.input ?? model.input,
+        inputLimits: mergeInputLimits(model.inputLimits, override.inputLimits),
         cost: override.cost
             ? {
                 input: override.cost.input ?? model.cost.input,
@@ -50,8 +82,13 @@ function applyModelOverride(model, override) {
                 tiers: override.cost.tiers ?? model.cost.tiers,
             }
             : model.cost,
+        promptCache: override.promptCache ? { ...model.promptCache, ...override.promptCache } : model.promptCache,
         contextWindow,
         maxTokens: safeMaxTokens(override.maxTokens ?? model.maxTokens, contextWindow, model.maxTokens),
+        samplingParams: override.samplingParams
+            ? { ...model.samplingParams, ...override.samplingParams }
+            : model.samplingParams,
+        samplingParamsByThinkingLevel: mergeSamplingParamsByThinkingLevel(model.samplingParamsByThinkingLevel, override.samplingParamsByThinkingLevel),
         compat: mergeCompat(model.compat, override.compat),
     };
 }
@@ -79,18 +116,49 @@ function modelFromJson(providerId, definition, providerConfig, defaults) {
         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,
         maxTokens: safeMaxTokens(definition.maxTokens, contextWindow),
+        samplingParams: definition.samplingParams,
+        samplingParamsByThinkingLevel: definition.samplingParamsByThinkingLevel,
         headers: undefined,
         compat: mergeCompat(providerConfig.compat, definition.compat),
     };
 }
 function findModelDefaults(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]);
+    const chatModels = models.filter((model) => isModelType(model, "chat"));
+    return (chatModels.find((model) => model.id === modelId) ??
+        (api ? chatModels.find((model) => model.api === api) : undefined) ??
+        chatModels.find((model) => model.api === "openai-completions") ??
+        chatModels[0]);
+}
+function findExtensionModelDefaults(models, definition) {
+    const type = definition.type ?? "chat";
+    const candidates = models.filter((model) => isModelType(model, type));
+    return (candidates.find((model) => model.id === definition.id) ??
+        (definition.api ? candidates.find((model) => model.api === definition.api) : undefined) ??
+        (type === "chat" ? candidates.find((model) => model.api === "openai-completions") : undefined) ??
+        candidates[0]);
+}
+function extensionModelFromDefinition(providerId, models, config, definition) {
+    const type = definition.type ?? "chat";
+    const defaults = findExtensionModelDefaults(models, definition);
+    const api = definition.api ?? (type === "chat" ? config.api : undefined) ?? defaults?.api;
+    if (!api) {
+        throw new Error(`Provider ${providerId}, model ${definition.id}: no "api" specified. Set it at model level${type === "chat" ? " or provider level" : ""}.`);
+    }
+    const baseUrl = definition.baseUrl ?? config.baseUrl ?? defaults?.baseUrl;
+    if (!baseUrl)
+        throw new Error(`Provider ${providerId}: "baseUrl" is required when defining custom models.`);
+    if (definition.type === "image") {
+        return { ...definition, api: api, provider: providerId, baseUrl, headers: undefined };
+    }
+    if (definition.type === "classifier") {
+        return { ...definition, api: api, provider: providerId, baseUrl, headers: undefined };
+    }
+    return { ...definition, api: api, provider: providerId, baseUrl, headers: undefined };
 }
 function applyModelsJson(providerId, baseModels, config) {
     if (!config)
@@ -109,13 +177,14 @@ function applyModelsJson(providerId, baseModels, config) {
         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: mergeCompat(model.compat, config.compat),
-    }));
+    const models = baseModels.map((model) => {
+        const baseUrl = config.oauth === "radius" ? model.baseUrl : (config.baseUrl ?? model.baseUrl);
+        return isModelType(model, "chat")
+            ? { ...model, baseUrl, compat: mergeCompat(model.compat, config.compat) }
+            : { ...model, baseUrl };
+    });
     for (const definition of config.models ?? []) {
-        const existingIndex = models.findIndex((model) => model.id === definition.id);
+        const existingIndex = models.findIndex((model) => isModelType(model, "chat") && model.id === definition.id);
         const defaults = findModelDefaults(models, definition.id, definition.api ?? config.api);
         const model = modelFromJson(providerId, definition, config, defaults);
         if (existingIndex >= 0)
@@ -131,27 +200,12 @@ function applyExtension(providerId, models, config) {
     if (!config.models) {
         return config.baseUrl ? models.map((model) => ({ ...model, baseUrl: config.baseUrl })) : [...models];
     }
-    return config.models.map((definition) => {
-        const defaults = findModelDefaults(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,
-        };
-    });
+    return config.models.map((definition) => extensionModelFromDefinition(providerId, models, config, definition));
 }
 function adaptOAuth(config) {
     return {
         name: config.name,
+        isSubscription: config.isSubscription,
         login: async (callbacks) => {
             const credential = await config.login({
                 onAuth: (info) => callbacks.notify({ type: "auth_url", ...info }),
@@ -164,7 +218,7 @@ function adaptOAuth(config) {
             });
             return { ...credential, type: "oauth" };
         },
-        refresh: async (credential) => ({ ...(await config.refreshToken(credential)), type: "oauth" }),
+        refresh: async (credential, signal) => ({ ...(await config.refreshToken(credential, signal)), type: "oauth" }),
         toAuth: async (credential) => ({ apiKey: config.getApiKey(credential) }),
     };
 }
@@ -281,11 +335,15 @@ function composeOAuthAuth(providerId, base, config, extension) {
     };
 }
 function rawModelHeaders(model, config, extension) {
-    const definition = config?.models?.find((entry) => entry.id === model.id);
-    const extensionModel = extension?.models?.find((entry) => entry.id === model.id);
+    // models.json definitions and overrides are chat-only. Extension definitions
+    // are matched by operation and id so colliding models cannot share headers.
+    const chatDefinition = isModelType(model, "chat")
+        ? config?.models?.find((entry) => entry.id === model.id)
+        : undefined;
+    const extensionModel = extension?.models?.find((entry) => (entry.type ?? "chat") === (model.type ?? "chat") && entry.id === model.id);
     const headers = {
-        ...config?.modelOverrides?.[model.id]?.headers,
-        ...definition?.headers,
+        ...(isModelType(model, "chat") ? config?.modelOverrides?.[model.id]?.headers : undefined),
+        ...chatDefinition?.headers,
         ...extensionModel?.headers,
     };
     return Object.keys(headers).length > 0 ? headers : undefined;
@@ -294,7 +352,7 @@ export function validateExtensionProvider(providerId, base, modelsConfig, extens
     if (extension.streamSimple && !extension.api) {
         throw new Error(`Provider ${providerId}: "api" is required when registering streamSimple.`);
     }
-    applyExtension(providerId, applyModelsJson(providerId, base?.getModels() ?? [], modelsConfig), extension);
+    applyExtension(providerId, applyModelsJson(providerId, getAllProviderModels(base), modelsConfig), extension);
 }
 /** Compose built-in, models.json, and extension layers without reading credentials. */
 export function composeModelProvider(providerId, base, modelConfig, extension) {
@@ -304,73 +362,117 @@ export function composeModelProvider(providerId, base, modelConfig, extension) {
     const currentExtension = () => 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 getModels = () => {
-        let models = applyExtension(providerId, applyModelsJson(providerId, base?.getModels() ?? [], config), currentExtension());
+    const getAllModels = () => {
+        let models = applyExtension(providerId, applyModelsJson(providerId, getAllProviderModels(base), config), currentExtension());
         if (extensionOAuthCredential && extension?.oauth?.modifyModels) {
-            models = extension.oauth.modifyModels(models, extensionOAuthCredential);
+            // The extension hook is chat-only; other model types pass through untouched.
+            models = [
+                ...extension.oauth.modifyModels(models.filter((model) => isModelType(model, "chat")), extensionOAuthCredential),
+                ...models.filter((model) => !isModelType(model, "chat")),
+            ];
         }
         return models.map((model) => {
             const override = config?.modelOverrides?.[model.id];
-            return override ? applyModelOverride(model, override) : model;
+            return override && isModelType(model, "chat") ? applyModelOverride(model, override) : model;
         });
     };
     // Validate eagerly so registration/reload reports structural errors immediately.
-    getModels();
+    getAllModels();
     const apiKey = composeApiKeyAuth(providerId, base, config, extension);
     const oauth = composeOAuthAuth(providerId, base, config, extension);
     if (!apiKey && !oauth)
         throw new Error(`Provider ${providerId}: no authentication method configured.`);
     const supportsBaseApi = (model) => base?.getModels().some((entry) => entry.api === model.api) ?? false;
     const streamWith = (model, context, options, simple) => lazyStream(model, async () => {
-        // Provider boundary: the platform's streaming entry points hand providers a
-        // branded TranscriptContext. Lift the ordinary request context here, where the
-        // fork forwards into a platform adapter.
-        const transcript = normalizeContext(context);
         if (extension?.streamSimple && model.api === extension.api) {
-            return extension.streamSimple(model, transcript, options);
+            return extension.streamSimple(model, context, options);
         }
         if (base && supportsBaseApi(model)) {
             return simple
-                ? base.streamSimple(model, transcript, options)
-                : base.stream(model, transcript, options);
+                ? base.streamSimple(model, context, options)
+                : base.stream(model, context, options);
         }
         const api = getApiProvider(model.api);
         if (!api)
             throw new Error(`No API provider registered for api: ${model.api}`);
         return simple
-            ? api.streamSimple(model, transcript, options)
-            : api.stream(model, transcript, options);
+            ? api.streamSimple(model, context, options)
+            : api.stream(model, context, options);
     });
-    return {
+    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,
+        getModels: () => getAllModels().filter((model) => isModelType(model, "chat")),
+        getAllModels,
         refreshModels: base?.refreshModels || extension?.refreshModels || extension?.oauth?.modifyModels
             ? async (context) => {
                 await base?.refreshModels?.(context);
-                if (extension?.refreshModels) {
-                    const refreshed = await extension.refreshModels(context);
-                    if (!context.signal?.aborted) {
-                        // Validate before publishing the new synchronous list.
-                        applyExtension(providerId, applyModelsJson(providerId, base?.getModels() ?? [], config), {
-                            ...extension,
-                            models: refreshed,
-                        });
-                        refreshedExtensionModels = refreshed;
-                    }
-                }
-                extensionOAuthCredential = context.credential?.type === "oauth" ? context.credential : undefined;
+                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.
+                            applyExtension(providerId, applyModelsJson(providerId, getAllProviderModels(base), config), {
+                                ...extension,
+                                models: refreshed,
+                            });
+                            refreshedExtensionModels = refreshed;
+                        }
+                        extensionOAuthCredential = oauthCredential;
+                    },
+                });
             }
             : undefined,
         filterModels: base?.filterModels
             ? (models, credential) => base.filterModels(models, credential)
             : undefined,
+        filterAllModels: base?.filterAllModels
+            ? (models, credential) => base.filterAllModels(models, credential)
+            : undefined,
         stream: (model, context, options) => streamWith(model, context, options, false),
         streamSimple: (model, context, options) => streamWith(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);
+    }
+    const extensionImages = extension?.images;
+    const generateImages = base?.generateImages;
+    if (generateImages || Object.keys(extensionImages ?? {}).length > 0) {
+        provider.generateImages = (model, context, options) => {
+            const implementation = extensionImages?.[model.api];
+            if (implementation)
+                return implementation.generateImages(model, context, options);
+            if (generateImages)
+                return generateImages(model, context, options);
+            return Promise.resolve(imageErrorResult(model, new Error(`Provider ${providerId} has no image implementation for "${model.api}"`)));
+        };
+    }
+    const extensionClassifiers = extension?.classifiers;
+    const classify = base?.classify;
+    if (classify || Object.keys(extensionClassifiers ?? {}).length > 0) {
+        provider.classify = (model, context, options) => {
+            const implementation = extensionClassifiers?.[model.api];
+            if (implementation)
+                return implementation.classify(model, context, options);
+            if (classify)
+                return classify(model, context, options);
+            return Promise.resolve(classifierErrorResult(model, new Error(`Provider ${providerId} has no classifier implementation for "${model.api}"`)));
+        };
+    }
+    return provider;
 }
 export function resolveConfiguredModelHeaders(model, config, extension, env) {
     return resolveHeadersOrThrow(rawModelHeaders(model, config, extension), `model "${model.provider}/${model.id}"`, env);

package/dist/core/radius.d.ts

@@ -1,4 +1,6 @@
 export declare const RADIUS_PROVIDER_ID = "radius";
 export declare const ENV_RADIUS_GATEWAY = "PI_RADIUS_GATEWAY";
+/** MCP endpoint of the gateway the built-in Radius provider signs in to. */
+export declare const RADIUS_MCP_URL: string;
 /** Radius gateway origin, honoring the `PI_RADIUS_GATEWAY` override. */
 export declare function getRadiusGatewayUrl(): string;

package/dist/core/radius.js

@@ -1,6 +1,8 @@
 import { DEFAULT_RADIUS_GATEWAY, normalizeRadiusGatewayUrl } from "@earendil-works/pi-ai/providers/radius-config";
 export const RADIUS_PROVIDER_ID = "radius";
 export const ENV_RADIUS_GATEWAY = "PI_RADIUS_GATEWAY";
+/** MCP endpoint of the gateway the built-in Radius provider signs in to. */
+export const RADIUS_MCP_URL = `${normalizeRadiusGatewayUrl(DEFAULT_RADIUS_GATEWAY)}/mcp`;
 /** Radius gateway origin, honoring the `PI_RADIUS_GATEWAY` override. */
 export function getRadiusGatewayUrl() {
     return normalizeRadiusGatewayUrl(process.env[ENV_RADIUS_GATEWAY] ?? DEFAULT_RADIUS_GATEWAY);

package/dist/core/remote-catalog-provider.d.ts

@@ -1,4 +1,11 @@
-import type { Provider } from "@earendil-works/pi-ai";
+import { type ModelType, type Provider } from "@earendil-works/pi-ai";
 export declare const REMOTE_CATALOG_REFRESH_INTERVAL_MS: number;
+/**
+ * Model types this client can consume. Sent as `?types=` so the catalog server
+ * returns the full-type shard instead of the chat-only one served to clients
+ * that predate model types. A server that ignores the parameter still returns
+ * the chat-only shard, which this client handles unchanged.
+ */
+export declare const REMOTE_CATALOG_MODEL_TYPES: readonly ModelType[];
 /** Add a persisted pi.dev catalog overlay to a static built-in provider. */
 export declare function withRemoteCatalog(provider: Provider, catalogBaseUrl?: string, localGeneratedAt?: number): Provider;

package/dist/core/remote-catalog-provider.js

@@ -1,17 +1,26 @@
+import { getModelType, isModelType, } from "@earendil-works/pi-ai";
 import { PI_PLATFORM_VERSION } from "../config.js";
+import { fetchWithRetry } from "../utils/management-http.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
+const REMOTE_CATALOG_ATTEMPT_TIMEOUT_MS = 4_000;
 const DEFAULT_CATALOG_BASE_URL = "https://pi.dev";
 export const REMOTE_CATALOG_REFRESH_INTERVAL_MS = 4 * 60 * 60 * 1000;
+/**
+ * Model types this client can consume. Sent as `?types=` so the catalog server
+ * returns the full-type shard instead of the chat-only one served to clients
+ * that predate model types. A server that ignores the parameter still returns
+ * the chat-only shard, which this client handles unchanged.
+ */
+export const REMOTE_CATALOG_MODEL_TYPES = ["chat", "image", "classifier"];
+function isSupportedModelType(model) {
+    return (model.type === undefined ||
+        (typeof model.type === "string" && REMOTE_CATALOG_MODEL_TYPES.includes(model.type)));
+}
 function mergeModels(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;
+    const merged = new Map();
+    for (const model of [...baseline, ...dynamic])
+        merged.set(`${getModelType(model)}\0${model.id}`, model);
+    return [...merged.values()];
 }
 function parseCatalog(providerId, value) {
     const entries = Array.isArray(value)
@@ -25,6 +34,7 @@ function parseCatalog(providerId, value) {
         throw new Error(`Invalid model catalog for provider "${providerId}"`);
     return entries
         .filter((entry) => typeof entry === "object" && entry !== null && "id" in entry)
+        .filter(isSupportedModelType)
         .map((model) => ({ ...model, provider: providerId }));
 }
 function remoteModels(entry, localGeneratedAt) {
@@ -44,7 +54,8 @@ export function withRemoteCatalog(provider, catalogBaseUrl = DEFAULT_CATALOG_BAS
     let dynamicModels = [];
     return {
         ...provider,
-        getModels: () => mergeModels(provider.getModels(), dynamicModels),
+        getModels: () => mergeModels(provider.getModels(), dynamicModels.filter((model) => isModelType(model, "chat"))),
+        getAllModels: () => mergeModels(provider.getAllModels?.() ?? provider.getModels(), dynamicModels),
         refreshModels: async (context) => {
             const stored = context.stored;
             const restored = remoteModels(stored, localGeneratedAt).filter((model) => model.provider === provider.id);
@@ -65,16 +76,17 @@ export function withRemoteCatalog(provider, catalogBaseUrl = DEFAULT_CATALOG_BAS
             }
             // 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 validator = stored && stored.models.length > 0 ? stored.etag : undefined;
             const url = new URL(`/api/models/providers/${encodeURIComponent(provider.id)}`, catalogBaseUrl);
-            const response = await fetch(url, {
+            url.searchParams.set("types", REMOTE_CATALOG_MODEL_TYPES.join(","));
+            const response = await fetchWithRetry(url, {
                 headers: {
                     accept: "application/json",
                     "User-Agent": getPiUserAgent(PI_PLATFORM_VERSION),
                     ...(validator ? { "if-none-match": validator } : {}),
                 },
                 signal: context.signal,
-            });
+            }, { attemptTimeoutMs: REMOTE_CATALOG_ATTEMPT_TIMEOUT_MS });
             if (context.signal.aborted)
                 return;
             const checkedAt = Date.now();

package/dist/core/resource-loader.d.ts

@@ -2,7 +2,7 @@ import { type Theme } from "../modes/interactive/theme/theme.ts";
 import type { ResourceDiagnostic } from "./diagnostics.ts";
 export type { ResourceCollision, ResourceDiagnostic } from "./diagnostics.ts";
 import { type EventBus } from "./event-bus.ts";
-import type { InlineExtension, LoadExtensionsResult } from "./extensions/types.ts";
+import type { ExtensionFactory, InlineExtension, LoadExtensionsResult } from "./extensions/types.ts";
 import { type PathMetadata, type ResolvedResource } from "./package-manager.ts";
 import type { PromptTemplate } from "./prompt-templates.ts";
 import { SettingsManager } from "./settings-manager.ts";
@@ -27,6 +27,9 @@ export interface ResourceLoaderReloadOptions {
         extensionsResult: LoadExtensionsResult;
     }) => Promise<boolean>;
 }
+type BuiltinExtension = Exclude<InlineExtension, ExtensionFactory>;
+/** Built-in extensions supply the code of `builtin:<name>` extension paths (see `InlineExtension`). */
+export declare function isBuiltinExtension(input: InlineExtension): input is BuiltinExtension;
 export interface ResourceLoader {
     /** Same-process extension bridge for host integrations; never exposed as an arbitrary RPC command. */
     getEventBus?(): EventBus;
@@ -99,6 +102,8 @@ export interface DefaultResourceLoaderOptions {
     additionalThemePaths?: string[];
     extensionFactories?: InlineExtension[];
     noExtensions?: boolean;
+    /** Built-in extensions not to load, by name (such as `mcp`), even when settings or `-e` enable them. */
+    disabledBuiltinExtensions?: string[];
     noSkills?: boolean;
     noAgents?: boolean;
     noPromptTemplates?: boolean;
@@ -161,7 +166,9 @@ export declare class DefaultResourceLoader implements ResourceLoader {
     private additionalPromptTemplatePaths;
     private additionalThemePaths;
     private extensionFactories;
+    private builtinExtensions;
     private noExtensions;
+    private disabledBuiltinExtensions;
     private noSkills;
     private noAgents;
     private noPromptTemplates;
@@ -244,6 +251,7 @@ export declare class DefaultResourceLoader implements ResourceLoader {
     reload(options?: ResourceLoaderReloadOptions): Promise<void>;
     private loadCurrentExtensionSet;
     private resolveExtensionLoadPath;
+    private loadExtensionPaths;
     private loadFinalExtensionSet;
     private addExtensionConflictDiagnostics;
     /**