@code-yeongyu/senpi-ai 2026.9.30 → 2026.10.1

package/dist/auth/resolve.js

@@ -1,7 +1,8 @@
 import { operationSignal, raceWithAbortSignal } from "../utils/abort.js";
-import { formatThrownValue } from "../utils/diagnostics.js";
+import { ModelsError } from "../utils/models-error.js";
 import { OAuthRefreshExchangeError, OAuthRefreshStoreError, projectOAuthSlot, refreshOAuthCredential, } from "./oauth-refresh.js";
 import { projectSlot } from "./pool/slots.js";
+export { ModelsError } from "../utils/models-error.js";
 /**
  * Prefix of the auth-miss every resolution site raises when a provider has no
  * usable credential. Consumers key recovery decisions off this exact wording,
@@ -12,24 +13,8 @@ export const PROVIDER_NOT_CONFIGURED_PREFIX = "Provider is not configured: ";
 export function providerNotConfiguredMessage(providerId) {
     return `${PROVIDER_NOT_CONFIGURED_PREFIX}${providerId}`;
 }
-export class ModelsError extends Error {
-    constructor(code, message, options) {
-        super(withCauseDetail(message, options?.cause), options);
-        this.name = "ModelsError";
-        this.code = code;
-    }
-}
-/** Callers surface `error.message` only, so keep the underlying reason in it. */
-function withCauseDetail(message, cause) {
-    if (cause === undefined || cause === null)
-        return message;
-    const detail = formatThrownValue(cause).trim();
-    if (!detail || message.includes(detail))
-        return message;
-    return `${message}: ${detail}`;
-}
 /**
- * Auth resolution shared by the `Models` and `ImagesModels` collections.
+ * Auth resolution shared by all operations in a `Models` collection.
  * A stored credential owns the provider: ambient/env is consulted only when
  * nothing is stored. No silent env fallback after a failed refresh or for a
  * credential type without a matching handler.

package/dist/auth/types.d.ts

@@ -212,6 +212,15 @@ export interface ApiKeyAuth {
         signal: AbortSignal;
     }): Promise<AuthResult | undefined>;
 }
+/** App-supplied context for `Models.login`. */
+export interface LoginOptions {
+    /**
+     * Returns the stable ID of this app installation, e.g. sent to OpenAI as its
+     * agent host ID. Called only by login flows that need it, so apps can create
+     * the ID on first use and must return the same ID on every later call.
+     */
+    getDeviceId?: () => string;
+}
 /**
  * OAuth auth. The `refresh`/`toAuth` split lets `Models` own the locked
  * refresh pattern: `refresh` produces a credential, `toAuth` derives request
@@ -231,7 +240,7 @@ export interface OAuthAuth {
      * request before surfacing the failure.
      */
     rejectedTokenStatuses?: readonly number[];
-    login(interaction: ProviderAuthInteraction): Promise<OAuthCredential>;
+    login(interaction: ProviderAuthInteraction, options?: LoginOptions): Promise<OAuthCredential>;
     /**
      * Exchange the refresh token. Network call; throws on failure
      * (invalid_grant etc.). `Models` runs this under the store lock.

package/dist/bun-oauth.js

@@ -5,6 +5,8 @@ import { devinOAuth } from "./auth/oauth/devin.js";
 import { githubCopilotOAuth } from "./auth/oauth/github-copilot.js";
 import { kimiCodingOAuth } from "./auth/oauth/kimi-coding.js";
 import { registerBundledOAuthFlowLoaders } from "./auth/oauth/load.js";
+import { metaOAuth } from "./auth/oauth/meta.js";
+import { openaiChatGPTOAuth } from "./auth/oauth/openai-chatgpt.js";
 import { openRouterOAuth } from "./auth/oauth/openrouter.js";
 import { createRadiusOAuth } from "./auth/oauth/radius.js";
 import { xaiOAuth } from "./auth/oauth/xai.js";
@@ -13,9 +15,11 @@ export function registerBunOAuthFlows() {
     registerBundledOAuthFlowLoaders({
         anthropic: () => anthropicOAuth,
         chatgptSubscription: () => chatgptSubscriptionOAuth,
+        openaiChatGPT: () => openaiChatGPTOAuth,
         githubCopilot: () => githubCopilotOAuth,
         openrouter: () => openRouterOAuth,
         kimiCoding: () => kimiCodingOAuth,
+        meta: () => metaOAuth,
         xai: () => xaiOAuth,
         cursor: () => cursorOAuth,
         devin: () => devinOAuth,

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { builtinProviders } from "./providers/all.js";
@@ -40,6 +41,7 @@ async function login(providerId) {
         throw new Error(`Unknown provider: ${providerId}`);
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     try {
+        // This dev CLI does not persist an installation ID; apps should reuse one across logins.
         const credential = await provider.auth.oauth.login({
             signal: new AbortController().signal,
             prompt: (authPrompt) => answerPrompt(rl, authPrompt),
@@ -60,7 +62,7 @@ async function login(providerId) {
                         break;
                 }
             },
-        });
+        }, { getDeviceId: randomUUID });
         const auth = loadAuth();
         auth[providerId] = credential;
         saveAuth(auth);

package/dist/compat.js

@@ -46,6 +46,7 @@ import { getEnvApiKey } from "./env-api-keys.js";
 import { builtinModels, getBuiltinModel, getBuiltinModels, getBuiltinProviders } from "./providers/all.js";
 import { createFauxCore } from "./providers/faux.js";
 import { getProtocol, getToolCallFormat, transformContext, wrapStreamWithToolCallMiddleware, } from "./tool-call-middleware/index.js";
+import { getCurrentTools, normalizeContext } from "./utils/transcript.js";
 /** @deprecated Static catalog read. Use `getBuiltinModel` from "@earendil-works/pi-ai/providers/all" or `Models.getModel()`. */
 export const getModel = getBuiltinModel;
 /** @deprecated Static catalog read. Use `getBuiltinModels` from "@earendil-works/pi-ai/providers/all" or `Models.getModels()`. */
@@ -137,44 +138,46 @@ function resolveApiProvider(api) {
     return provider;
 }
 export function stream(model, context, options) {
+    const transcript = normalizeContext(context);
     const format = getToolCallFormat(model);
-    if (format && context.tools && context.tools.length > 0) {
+    const tools = getCurrentTools(transcript.messages);
+    if (format && tools.length > 0) {
         const protocol = getProtocol(format);
-        const transformedContext = transformContext(context, protocol);
-        const innerStream = stream(model, transformedContext, options);
-        return wrapStreamWithToolCallMiddleware(innerStream, protocol, context.tools);
+        const innerStream = stream(model, transformContext(transcript, protocol), options);
+        return wrapStreamWithToolCallMiddleware(innerStream, protocol, tools);
     }
     const builtinProvider = getBuiltinProviderForModel(model);
     if (builtinProvider) {
         if (model.provider.startsWith("cloudflare-") && !hasResolvedCloudflareAuth(options)) {
-            return compatModels.stream(model, context, options);
+            return compatModels.stream(model, transcript, options);
         }
-        return builtinProvider.stream(model, context, withEnvApiKey(model, options));
+        return builtinProvider.stream(model, transcript, withEnvApiKey(model, options));
     }
     const provider = resolveApiProvider(model.api);
-    return provider.stream(model, context, withEnvApiKey(model, options));
+    return provider.stream(model, transcript, withEnvApiKey(model, options));
 }
 export async function complete(model, context, options) {
     const s = stream(model, context, options);
     return s.result();
 }
 export function streamSimple(model, context, options) {
+    const transcript = normalizeContext(context);
     const format = getToolCallFormat(model);
-    if (format && context.tools && context.tools.length > 0) {
+    const tools = getCurrentTools(transcript.messages);
+    if (format && tools.length > 0) {
         const protocol = getProtocol(format);
-        const transformedContext = transformContext(context, protocol);
-        const innerStream = streamSimple(model, transformedContext, options);
-        return wrapStreamWithToolCallMiddleware(innerStream, protocol, context.tools);
+        const innerStream = streamSimple(model, transformContext(transcript, protocol), options);
+        return wrapStreamWithToolCallMiddleware(innerStream, protocol, tools);
     }
     const builtinProvider = getBuiltinProviderForModel(model);
     if (builtinProvider) {
         if (model.provider.startsWith("cloudflare-") && !hasResolvedCloudflareAuth(options)) {
-            return compatModels.streamSimple(model, context, options);
+            return compatModels.streamSimple(model, transcript, options);
         }
-        return builtinProvider.streamSimple(model, context, withEnvApiKey(model, options));
+        return builtinProvider.streamSimple(model, transcript, withEnvApiKey(model, options));
     }
     const provider = resolveApiProvider(model.api);
-    return provider.streamSimple(model, context, withEnvApiKey(model, options));
+    return provider.streamSimple(model, transcript, withEnvApiKey(model, options));
 }
 export async function completeSimple(model, context, options) {
     const s = streamSimple(model, context, options);

package/dist/env-api-keys.js

@@ -91,6 +91,7 @@ export function getApiKeyEnvVars(provider) {
         cerebras: "CEREBRAS_API_KEY",
         venice: "VENICE_API_KEY",
         xai: "XAI_API_KEY",
+        typesafe: "TYPESAFE_API_KEY",
         radius: "RADIUS_API_KEY",
         openrouter: "OPENROUTER_API_KEY",
         "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
@@ -110,6 +111,7 @@ export function getApiKeyEnvVars(provider) {
         opencode: "OPENCODE_API_KEY",
         "opencode-go": "OPENCODE_API_KEY",
         "kimi-coding": "KIMI_API_KEY",
+        meta: "META_API_KEY",
         "cloudflare-workers-ai": "CLOUDFLARE_API_KEY",
         "cloudflare-ai-gateway": "CLOUDFLARE_API_KEY",
         xiaomi: "XIAOMI_API_KEY",

package/dist/image-models.d.ts

@@ -1,10 +1,21 @@
-import { IMAGE_MODELS } from "./image-models.generated.ts";
-import type { ImagesApi, ImagesModel, KnownImagesProvider } from "./types.ts";
-type ImageModelApi<TProvider extends KnownImagesProvider, TModelId extends keyof (typeof IMAGE_MODELS)[TProvider]> = (typeof IMAGE_MODELS)[TProvider][TModelId] extends {
-    api: infer TApi;
-} ? TApi extends ImagesApi ? TApi : never : never;
-export declare function getImageModel<TProvider extends KnownImagesProvider, TModelId extends keyof (typeof IMAGE_MODELS)[TProvider]>(provider: TProvider, modelId: TModelId): ImagesModel<ImageModelApi<TProvider, TModelId>>;
-export declare function getImageProviders(): KnownImagesProvider[];
-export declare function getImageModels<TProvider extends KnownImagesProvider>(provider: TProvider): ImagesModel<ImageModelApi<TProvider, keyof (typeof IMAGE_MODELS)[TProvider]>>[];
+import { IMAGE_MODELS } from "./models.generated.ts";
+import type { ImageApi, ImageModel } from "./types.ts";
+/**
+ * Compat reads of the generated catalog restricted to image models. New code
+ * uses `Models.getModelOfType("image", ...)` or `getBuiltinImageModel()` from `providers/all`.
+ */
+type Catalog = typeof IMAGE_MODELS;
+type ImageModelIds<TProvider extends keyof Catalog> = keyof Catalog[TProvider];
+/** Built-in providers with at least one image model in the generated catalog. */
+export type BuiltinImageProvider = {
+    [TProvider in keyof Catalog]: [ImageModelIds<TProvider>] extends [never] ? never : TProvider;
+}[keyof Catalog];
+type BuiltinImageModel<TProvider extends BuiltinImageProvider, TModelId extends ImageModelIds<TProvider>> = Catalog[TProvider][TModelId] extends ImageModel<infer TApi extends ImageApi> ? ImageModel<TApi> : never;
+/** @deprecated Static catalog read. Use `getBuiltinImageModel` from "@earendil-works/pi-ai/providers/all" or `Models.getModelOfType("image", ...)`. */
+export declare function getImageModel<TProvider extends BuiltinImageProvider, TModelId extends ImageModelIds<TProvider>>(provider: TProvider, modelId: TModelId): BuiltinImageModel<TProvider, TModelId>;
+/** @deprecated Static catalog read. Use `Models.getProviders()`. */
+export declare function getImageProviders(): BuiltinImageProvider[];
+/** @deprecated Static catalog read. Use `getBuiltinImageModels` from "@earendil-works/pi-ai/providers/all" or `Models.getModelsOfType("image")`. */
+export declare function getImageModels<TProvider extends BuiltinImageProvider>(provider: TProvider): BuiltinImageModel<TProvider, ImageModelIds<TProvider>>[];
 export {};
 //# sourceMappingURL=image-models.d.ts.map

package/dist/image-models.js

@@ -1,23 +1,24 @@
-import { IMAGE_MODELS } from "./image-models.generated.js";
-const imageModelRegistry = new Map();
+import { IMAGE_MODELS } from "./models.generated.js";
+const imageModelsByProvider = new Map();
 for (const [provider, models] of Object.entries(IMAGE_MODELS)) {
-    const providerModels = new Map();
-    for (const [id, model] of Object.entries(models)) {
-        providerModels.set(id, model);
+    const imageModels = new Map();
+    for (const model of Object.values(models)) {
+        imageModels.set(model.id, model);
     }
-    imageModelRegistry.set(provider, providerModels);
+    if (imageModels.size > 0)
+        imageModelsByProvider.set(provider, imageModels);
 }
+/** @deprecated Static catalog read. Use `getBuiltinImageModel` from "@earendil-works/pi-ai/providers/all" or `Models.getModelOfType("image", ...)`. */
 export function getImageModel(provider, modelId) {
-    const providerModels = imageModelRegistry.get(provider);
-    return providerModels?.get(modelId);
+    return imageModelsByProvider.get(provider)?.get(modelId);
 }
+/** @deprecated Static catalog read. Use `Models.getProviders()`. */
 export function getImageProviders() {
-    return Array.from(imageModelRegistry.keys());
+    return Array.from(imageModelsByProvider.keys());
 }
+/** @deprecated Static catalog read. Use `getBuiltinImageModels` from "@earendil-works/pi-ai/providers/all" or `Models.getModelsOfType("image")`. */
 export function getImageModels(provider) {
-    const models = imageModelRegistry.get(provider);
-    return models
-        ? Array.from(models.values())
-        : [];
+    const models = imageModelsByProvider.get(provider);
+    return models ? Array.from(models.values()) : [];
 }
 //# sourceMappingURL=image-models.js.map

package/dist/images-api-registry.d.ts

@@ -1,11 +1,11 @@
-import type { AssistantImages, ImagesApi, ImagesContext, ImagesFunction, ImagesModel, ImagesOptions } from "./types.ts";
-export type ImagesApiFunction = (model: ImagesModel<ImagesApi>, context: ImagesContext, options?: ImagesOptions) => Promise<AssistantImages>;
-export interface ImagesApiProvider<TApi extends ImagesApi = ImagesApi, TOptions extends ImagesOptions = ImagesOptions> {
+import type { AssistantImages, ImageApi, ImageModel, ImagesContext, ImagesFunction, ImagesOptions } from "./types.ts";
+export type ImagesApiFunction = (model: ImageModel<ImageApi>, context: ImagesContext, options?: ImagesOptions) => Promise<AssistantImages>;
+export interface ImagesApiProvider<TApi extends ImageApi = ImageApi, TOptions extends ImagesOptions = ImagesOptions> {
     api: TApi;
-    generateImages: ImagesFunction<TApi, TOptions>;
+    generateImages: ImagesFunction<TOptions>;
 }
 export interface ImagesApiProviderInternal {
-    api: ImagesApi;
+    api: ImageApi;
     generateImages: ImagesApiFunction;
 }
 export type RegisteredImagesApiProvider = {
@@ -20,10 +20,10 @@ export interface ImagesProviderScopeAccess {
 /** Installs the optional node-only scope lookup without importing node APIs here. */
 export declare function installImagesProviderScopeAccessor(accessor: () => ImagesProviderScopeAccess | undefined): void;
 export declare function setImagesProviderScopeStrictMode(enabled: boolean): void;
-export declare function registerImagesApiProvider<TApi extends ImagesApi, TOptions extends ImagesOptions>(provider: ImagesApiProvider<TApi, TOptions>, sourceId?: string): void;
+export declare function registerImagesApiProvider<TApi extends ImageApi, TOptions extends ImagesOptions>(provider: ImagesApiProvider<TApi, TOptions>, sourceId?: string): void;
 /** Registers a builtin once, retaining its immutable identity for active scopes. */
-export declare function registerBuiltinImagesApiProvider<TApi extends ImagesApi, TOptions extends ImagesOptions>(provider: ImagesApiProvider<TApi, TOptions>): void;
-export declare function getImagesApiProvider(api: ImagesApi): ImagesApiProviderInternal | undefined;
+export declare function registerBuiltinImagesApiProvider<TApi extends ImageApi, TOptions extends ImagesOptions>(provider: ImagesApiProvider<TApi, TOptions>): void;
+export declare function getImagesApiProvider(api: ImageApi): ImagesApiProviderInternal | undefined;
 export declare function getImagesApiProviders(): ImagesApiProviderInternal[];
 export declare function unregisterImagesApiProviders(sourceId: string): void;
 export declare function clearImagesApiProviders(): void;

package/dist/images.d.ts

@@ -1,5 +1,10 @@
 import "./providers/images/register-builtins.ts";
-import type { AssistantImages, ImagesApi, ImagesContext, ImagesModel, ProviderImagesOptions } from "./types.ts";
+import type { AssistantImages, ImageApi, ImageModel, ImagesContext, ProviderImagesOptions } from "./types.ts";
 export { type OpenAIImageBackground, type OpenAIImageModeration, type OpenAIImageOutputFormat, type OpenAIImageOutputOptions, type OpenAIImageQuality, type OpenAIImageSize, type OpenAIImagesOptions, parseOpenAIImageOutputOptions, parseOpenAIImageSize, } from "./api/openai-images-params.ts";
-export declare function generateImages<TApi extends ImagesApi>(model: ImagesModel<TApi>, context: ImagesContext, options?: ProviderImagesOptions): Promise<AssistantImages>;
+/**
+ * Global image generation dispatched on `model.api` through the images api
+ * registry. Auth must be passed explicitly via `options.apiKey`; prefer
+ * `Models.generateImages()`, which resolves provider auth.
+ */
+export declare function generateImages(model: ImageModel<ImageApi>, context: ImagesContext, options?: ProviderImagesOptions): Promise<AssistantImages>;
 //# sourceMappingURL=images.d.ts.map

package/dist/images.js

@@ -8,6 +8,11 @@ function resolveImagesApiProvider(api) {
     }
     return provider;
 }
+/**
+ * Global image generation dispatched on `model.api` through the images api
+ * registry. Auth must be passed explicitly via `options.apiKey`; prefer
+ * `Models.generateImages()`, which resolves provider auth.
+ */
 export async function generateImages(model, context, options) {
     const provider = resolveImagesApiProvider(model.api);
     return provider.generateImages(model, context, options);

package/dist/index.d.ts

@@ -32,7 +32,6 @@ export { CURSOR_MODEL_CAPABILITIES, type CursorCapabilityEvidence, type CursorLe
 export { type CursorResolvedSelection, renderCursorCliModelString, resolveCursorSelectionDescriptor, } from "./cursor/selection-descriptor.ts";
 export * from "./endpoint-reasoning-efforts.ts";
 export * from "./env-api-keys.ts";
-export * from "./images-models.ts";
 export * from "./legacy-provider-ids.ts";
 export * from "./models.ts";
 export * from "./models-store.ts";
@@ -59,8 +58,9 @@ export * from "./utils/provider-failure-description.ts";
 export * from "./utils/retry.ts";
 export * from "./utils/server-fallback-receipt.ts";
 export * from "./utils/stop-details.ts";
-export { contentText } from "./utils/text.ts";
+export { contentText, getSystemMessageText, renderSystemMessageUpdate } from "./utils/text.ts";
 export * from "./utils/tool-pair-repair.ts";
+export * from "./utils/transcript.ts";
 export * from "./utils/typebox-helpers.ts";
 export { uuidv7 } from "./utils/uuid.ts";
 export * from "./utils/validation.ts";

package/dist/index.js

@@ -18,7 +18,6 @@ export { CURSOR_MODEL_CAPABILITIES, getCursorBaseIdForVariant, getCursorCapabili
 export { renderCursorCliModelString, resolveCursorSelectionDescriptor, } from "./cursor/selection-descriptor.js";
 export * from "./endpoint-reasoning-efforts.js";
 export * from "./env-api-keys.js";
-export * from "./images-models.js";
 export * from "./legacy-provider-ids.js";
 export * from "./models.js";
 export * from "./models-store.js";
@@ -45,8 +44,9 @@ export * from "./utils/provider-failure-description.js";
 export * from "./utils/retry.js";
 export * from "./utils/server-fallback-receipt.js";
 export * from "./utils/stop-details.js";
-export { contentText } from "./utils/text.js";
+export { contentText, getSystemMessageText, renderSystemMessageUpdate } from "./utils/text.js";
 export * from "./utils/tool-pair-repair.js";
+export * from "./utils/transcript.js";
 export * from "./utils/typebox-helpers.js";
 export { uuidv7 } from "./utils/uuid.js";
 export * from "./utils/validation.js";

package/dist/model-catalog.d.ts

@@ -1,17 +1,35 @@
-import type { Api, Model, ProviderId } from "./types.ts";
+import type { Api, ClassifierApi, ClassifierModel, ImageApi, ImageModel, Model, ModelType, ProviderId } from "./types.ts";
 export type ModelGroups = Record<string, Record<string, object>>;
-type ModelId<TGroups extends ModelGroups> = {
+/** Exact-id lookup, matching getBuiltinModel(): provider namespaces remain part of the model id. */
+export declare function builtinCatalogAdvertisesMax(modelId: string): boolean;
+type ModelKey<TGroups extends ModelGroups> = {
     [TApi in keyof TGroups]: keyof TGroups[TApi];
 }[keyof TGroups] & string;
-type ModelApi<TGroups extends ModelGroups, TModelId extends ModelId<TGroups>> = {
-    [TApi in keyof TGroups]: TModelId extends keyof TGroups[TApi] ? TApi : never;
-}[keyof TGroups] & Api;
-export type ModelCatalog<TGroups extends ModelGroups, TProvider extends ProviderId> = {
-    [TModelId in ModelId<TGroups>]: Model<ModelApi<TGroups, TModelId>> & {
-        id: TModelId;
+type KeyForType<TGroups extends ModelGroups, TType extends ModelType> = Extract<ModelKey<TGroups>, `${TType}:${string}`>;
+type ModelId<TKey extends string> = TKey extends `${ModelType}:${infer TModelId}` ? TModelId : never;
+type ApiForKey<TGroups extends ModelGroups, TKey extends ModelKey<TGroups>> = {
+    [TApi in keyof TGroups]: TKey extends keyof TGroups[TApi] ? TApi : never;
+}[keyof TGroups];
+export type ChatModelCatalog<TGroups extends ModelGroups, TProvider extends ProviderId> = {
+    [TKey in KeyForType<TGroups, "chat"> as ModelId<TKey>]: Model<ApiForKey<TGroups, TKey> & Api> & {
+        id: ModelId<TKey>;
         provider: TProvider;
     };
 };
-export declare function flattenModelCatalog<const TProvider extends ProviderId, const TGroups extends ModelGroups>(_provider: TProvider, groups: TGroups): ModelCatalog<TGroups, TProvider>;
+export type ImageModelCatalog<TGroups extends ModelGroups, TProvider extends ProviderId> = {
+    [TKey in KeyForType<TGroups, "image"> as ModelId<TKey>]: ImageModel<ApiForKey<TGroups, TKey> & ImageApi> & {
+        id: ModelId<TKey>;
+        provider: TProvider;
+    };
+};
+export type ClassifierModelCatalog<TGroups extends ModelGroups, TProvider extends ProviderId> = {
+    [TKey in KeyForType<TGroups, "classifier"> as ModelId<TKey>]: ClassifierModel<ApiForKey<TGroups, TKey> & ClassifierApi> & {
+        id: ModelId<TKey>;
+        provider: TProvider;
+    };
+};
+export declare function flattenChatModelCatalog<const TProvider extends ProviderId, const TGroups extends ModelGroups>(_provider: TProvider, groups: TGroups): ChatModelCatalog<TGroups, TProvider>;
+export declare function flattenImageModelCatalog<const TProvider extends ProviderId, const TGroups extends ModelGroups>(_provider: TProvider, groups: TGroups): ImageModelCatalog<TGroups, TProvider>;
+export declare function flattenClassifierModelCatalog<const TProvider extends ProviderId, const TGroups extends ModelGroups>(_provider: TProvider, groups: TGroups): ClassifierModelCatalog<TGroups, TProvider>;
 export {};
 //# sourceMappingURL=model-catalog.d.ts.map

package/dist/model-catalog.js

@@ -1,4 +1,26 @@
-export function flattenModelCatalog(_provider, groups) {
-    return Object.assign({}, ...Object.values(groups));
+const MAX_EFFORT_MODEL_IDS = new Set();
+/** Exact-id lookup, matching getBuiltinModel(): provider namespaces remain part of the model id. */
+export function builtinCatalogAdvertisesMax(modelId) {
+    return MAX_EFFORT_MODEL_IDS.has(modelId);
+}
+function flattenModelCatalog(groups, type) {
+    return Object.fromEntries(Object.values(groups)
+        .flatMap((models) => Object.values(models))
+        .filter((model) => model.type === type)
+        .map((model) => [model.id, model]));
+}
+export function flattenChatModelCatalog(_provider, groups) {
+    const catalog = flattenModelCatalog(groups, "chat");
+    for (const model of Object.values(catalog)) {
+        if (typeof model.thinkingLevelMap?.max === "string")
+            MAX_EFFORT_MODEL_IDS.add(model.id);
+    }
+    return catalog;
+}
+export function flattenImageModelCatalog(_provider, groups) {
+    return flattenModelCatalog(groups, "image");
+}
+export function flattenClassifierModelCatalog(_provider, groups) {
+    return flattenModelCatalog(groups, "classifier");
 }
 //# sourceMappingURL=model-catalog.js.map

package/dist/model.d.ts

@@ -1,11 +1,12 @@
-import type { AnthropicMessagesCompat, Api, BedrockCompat, CacheRetention, ModelCost, ModelThinkingLevel, OpenAICompletionsCompat, OpenAIResponsesCompat, ProviderId, ThinkingLevelMap } from "./types.ts";
-/** Model interface for the unified model system. */
-export interface Model<TApi extends Api> {
-    id: string;
-    name: string;
-    api: TApi;
-    provider: ProviderId;
-    baseUrl: string;
+import type { AnthropicMessagesCompat, Api, BaseModel, BedrockCompat, CacheRetention, MistralConversationsCompat, ModelPromptCache, ModelThinkingLevel, OpenAICompletionsCompat, OpenAIResponsesCompat, ThinkingLevelMap } from "./types.ts";
+/** Chat model: usable with `stream()` and friends. */
+export interface Model<TApi extends Api> extends BaseModel<TApi> {
+    /**
+     * Optional: chat is the default model type, so models without `type` are chat
+     * models. Narrow mixed model lists with `isModelType()` instead of comparing
+     * `type` directly.
+     */
+    type?: "chat";
     reasoning: boolean;
     /**
      * Maps pi thinking levels to provider/model-specific values.
@@ -18,13 +19,12 @@ export interface Model<TApi extends Api> {
      * OpenAI-compatible endpoint advertises. Clamped to the supported levels like any other request.
      */
     defaultThinkingLevel?: ModelThinkingLevel;
-    input: ("text" | "image" | "video")[];
-    cost: ModelCost;
+    /** Prompt cache lifetimes per retention tier. Unset when the provider's cache behavior is unknown. */
+    promptCache?: ModelPromptCache;
     contextWindow: number;
     maxTokens: number;
     /** Default sampling parameters; per-request values override these by key. */
     samplingParams?: Record<string, unknown>;
-    headers?: Record<string, string>;
     /** Default prompt-cache retention preference when the request omits one. */
     cacheRetention?: CacheRetention;
     /**
@@ -33,11 +33,11 @@ export interface Model<TApi extends Api> {
      */
     upstreamModelId?: string;
     /** Service tier requested by default for this model (for example `-fast` variants). */
-    serviceTier?: "auto" | "flex" | "priority";
+    serviceTier?: "auto" | "flex" | "priority" | "ultrafast";
     /** Whether to recover supported text-encoded tool calls from assistant text. */
     recoverTextToolCalls?: boolean;
     /** Compatibility overrides for OpenAI-compatible APIs. If not set, auto-detected from baseUrl. */
-    compat?: TApi extends "openai-completions" ? OpenAICompletionsCompat : TApi extends "openai-responses" | "openai-codex-responses" | "azure-openai-responses" ? OpenAIResponsesCompat : TApi extends "anthropic-messages" ? AnthropicMessagesCompat : TApi extends "bedrock-converse-stream" ? BedrockCompat : TApi extends "cursor-agent" ? CursorAgentCompat : TApi extends "devin-agent" ? DevinAgentCompat : never;
+    compat?: TApi extends "openai-completions" ? OpenAICompletionsCompat : TApi extends "openai-responses" | "openai-codex-responses" | "azure-openai-responses" ? OpenAIResponsesCompat : TApi extends "anthropic-messages" ? AnthropicMessagesCompat : TApi extends "bedrock-converse-stream" ? BedrockCompat : TApi extends "mistral-conversations" ? MistralConversationsCompat : TApi extends "cursor-agent" ? CursorAgentCompat : TApi extends "devin-agent" ? DevinAgentCompat : never;
 }
 /** Devin (Cascade) model metadata the transport branches on. */
 export interface DevinAgentCompat {

package/dist/models-store.d.ts

@@ -1,6 +1,7 @@
-import type { Api, Model } from "./types.ts";
+import type { AnyModel } from "./types.ts";
 export interface ModelsStoreEntry {
-    models: readonly Model<Api>[];
+    /** Persisted models of every type. */
+    models: readonly AnyModel[];
     /** Unix timestamp from the remote catalog's Last-Modified header. */
     lastModified?: number;
     /** Unix timestamp of the last completed remote check. */