@f5-sales-demo/pi-ai 22.4.11 → 22.5.1

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/pi-ai",
-	"version": "22.4.11",
+	"version": "22.5.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -43,17 +43,17 @@
 		"generate-models": "bun scripts/generate-models.ts"
 	},
 	"dependencies": {
-		"@anthropic-ai/sdk": "0.123.0",
-		"@aws-sdk/client-bedrock-runtime": "3.1126.0",
+		"@anthropic-ai/sdk": "0.124.0",
+		"@aws-sdk/client-bedrock-runtime": "3.1127.0",
 		"@bufbuild/protobuf": "2.14.1",
-		"@f5-sales-demo/pi-utils": "22.4.11",
+		"@f5-sales-demo/pi-utils": "22.5.1",
 		"@google/genai": "2.21.0",
 		"@sinclair/typebox": "0.34.52",
 		"@smithy/node-http-handler": "4.12.1",
 		"ajv": "^8.20",
 		"ajv-formats": "^3.0",
 		"google-auth-library": "10.9.1",
-		"openai": "7.9.0",
+		"openai": "7.19.0",
 		"partial-json": "^0.1",
 		"zod": "4.5.4"
 	},

package/src/api-registry.ts

@@ -15,6 +15,8 @@ import type {
 } from "./types";
 
 const BUILTIN_APIS = new Set<KnownApi>([
+	"pi-messages",
+	"mistral-conversations",
 	"openai-completions",
 	"openai-responses",
 	"openai-codex-responses",

package/src/codex-model-interaction.ts

@@ -64,6 +64,7 @@ function metadata(
 }
 
 export const CODEX_MODEL_INTERACTION_METADATA: Readonly<Record<string, CodexModelInteractionMetadata>> = {
+	"gpt-6.1-sol": metadata("medium", ["low", "medium", "high", "xhigh", "max", "ultra"], "default", 872_000, 922_000),
 	"gpt-6-astra": metadata(
 		"low",
 		["low", "medium", "high", "xhigh", "max", "ultra"],
@@ -141,11 +142,26 @@ export function applyCodexInteractionMetadata<TApi extends Api>(
 		providerContextWindow ??
 		model.providerContextWindow ??
 		(model.provider === "openai-codex" ? interaction.maxContextWindow : model.contextWindow);
-	const advertisedLimit = Math.min(rawProviderLimit, interaction.internalProviderMaxContextWindow);
+	const advertisedLimit = Math.min(
+		rawProviderLimit,
+		model.maxInputTokens ?? Number.POSITIVE_INFINITY,
+		interaction.internalProviderMaxContextWindow,
+	);
 	const budget = resolveCodexContextBudget(model.id, "standard", advertisedLimit)!;
 	return {
 		...model,
-		thinking: interaction.thinking,
+		...(model.provider === "openai-codex" && model.id === "gpt-6.1-sol"
+			? { compat: { supportsWebSocketSteering: true, ...model.compat } as Model<TApi>["compat"] }
+			: {}),
+		thinking:
+			model.provider === "openai-codex"
+				? (model.thinking ?? interaction.thinking)
+				: model.id === "gpt-6.1-sol"
+					? {
+							...interaction.thinking,
+							supportedLevels: interaction.thinking.supportedLevels.filter(level => level.effort !== "ultra"),
+						}
+					: interaction.thinking,
 		contextWindow: budget.contextWindow,
 		maxContextWindow: interaction.maxContextWindow,
 		maxTokens: interaction.outputLimit,
@@ -156,8 +172,8 @@ export function applyCodexInteractionMetadata<TApi extends Api>(
 		autoCompactTokenLimit: budget.autoCompactTokenLimit,
 		defaultReasoningSummary: interaction.defaultReasoningSummary,
 		defaultVerbosity: interaction.defaultVerbosity,
-		serviceTiers: interaction.serviceTiers,
-		defaultServiceTier: interaction.defaultServiceTier,
+		serviceTiers: model.serviceTiers ?? interaction.serviceTiers,
+		defaultServiceTier: model.defaultServiceTier ?? interaction.defaultServiceTier,
 		truncationPolicy: interaction.truncationPolicy,
 		supportsParallelToolCalls: interaction.supportsParallelToolCalls,
 	};

package/src/deferred.ts

@@ -0,0 +1,198 @@
+import { buildParams } from "./providers/openai-responses";
+import { processResponsesStream } from "./providers/openai-responses-shared";
+import { validateFinalResponsesRequest } from "./providers/sol-request-boundary";
+import { getEnvApiKey } from "./stream";
+import type { AssistantMessage, Context, DeferredHandle, Model, OperationOptions } from "./types";
+import { createOpenAIResponsesHistoryPayload } from "./utils";
+import { AssistantMessageEventStream } from "./utils/event-stream";
+import { retryProviderRequest } from "./utils/provider-retry";
+
+export type DeferredRequestOptions = OperationOptions &
+	Pick<
+		import("./providers/openai-responses").OpenAIResponsesOptions,
+		"reasoning" | "reasoningSummary" | "promptCache" | "serviceTier" | "toolChoice" | "maxTokens"
+	>;
+
+export interface DeferredResponse {
+	id: string;
+	status: "queued" | "in_progress" | "completed" | "incomplete" | "failed" | "cancelled";
+	output: Record<string, unknown>[];
+}
+function validateRoute(model: Model, handle?: DeferredHandle): void {
+	if (model.type !== undefined && model.type !== "chat") throw new Error("Deferred operations require a chat model");
+	if (model.api !== "openai-responses" || model.provider === "openai-codex")
+		throw new Error("Deferred Responses unsupported on this route");
+	if (
+		handle &&
+		(handle.provider !== model.provider ||
+			handle.modelId !== model.id ||
+			handle.api !== model.api ||
+			handle.baseUrl !== model.baseUrl)
+	)
+		throw new Error("Deferred handle belongs to a different route");
+	if (handle?.expiresAt && handle.expiresAt < Date.now()) throw new Error("Deferred handle expired");
+}
+async function request(
+	model: Model,
+	path: string,
+	method: string,
+	options: OperationOptions,
+	payload?: unknown,
+): Promise<DeferredResponse> {
+	options.signal?.throwIfAborted();
+	const apiKey = options.apiKey ?? getEnvApiKey(model.provider);
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const timeoutSignal = options.timeoutMs !== undefined ? AbortSignal.timeout(options.timeoutMs) : undefined;
+	const signal =
+		options.signal && timeoutSignal
+			? AbortSignal.any([options.signal, timeoutSignal])
+			: (options.signal ?? timeoutSignal);
+	const response = await retryProviderRequest(
+		async () => {
+			const result = await (options.fetch ?? globalThis.fetch)(
+				`${model.baseUrl.replace(/\/+$/, "")}/responses${path}`,
+				{
+					method,
+					headers: {
+						...model.headers,
+						...options.headers,
+						Authorization: `Bearer ${apiKey}`,
+						"Content-Type": "application/json",
+					},
+					...(payload === undefined ? {} : { body: JSON.stringify(payload) }),
+					signal,
+				},
+			);
+			if (!result.ok)
+				throw Object.assign(new Error(`Deferred Responses HTTP ${result.status}`), {
+					status: result.status,
+					headers: result.headers,
+				});
+			return result;
+		},
+		{ ...options, signal },
+	);
+	await options.onResponse?.(
+		{ status: response.status, headers: Object.fromEntries(response.headers.entries()) },
+		model,
+	);
+	const body = (await response.json()) as DeferredResponse;
+	if (
+		!body ||
+		typeof body.id !== "string" ||
+		!Array.isArray(body.output) ||
+		!["queued", "in_progress", "completed", "incomplete", "failed", "cancelled"].includes(body.status)
+	)
+		throw new Error("Malformed deferred response");
+	return body;
+}
+export async function requestDeferred(
+	model: Model,
+	context: Context,
+	options: DeferredRequestOptions = {},
+): Promise<DeferredHandle> {
+	options.signal?.throwIfAborted();
+	validateRoute(model);
+	let payload: Record<string, unknown> = {
+		...buildParams(
+			model as Model<"openai-responses">,
+			context,
+			options as import("./providers/openai-responses").OpenAIResponsesOptions,
+			undefined,
+		).params,
+		background: true,
+		store: true,
+		stream: false,
+	};
+	const replacement = await options.onPayload?.(payload, model);
+	if (replacement !== undefined) payload = replacement as Record<string, unknown>;
+	validateFinalResponsesRequest(model, payload);
+	Object.assign(payload, { background: true, store: true, stream: false });
+	const response = await request(model, "", "POST", options, payload);
+	return {
+		provider: model.provider,
+		modelId: model.id,
+		api: model.api,
+		baseUrl: model.baseUrl,
+		id: response.id,
+		pollAfterMs: 1000,
+		data: {
+			grammarTools: (context.tools ?? [])
+				.filter(tool => tool.constrainedSampling && tool.constrainedSampling.type === "grammar")
+				.map(tool => [tool.name, (tool.parameters as { required?: string[] }).required?.[0] ?? "input"]),
+		},
+	};
+}
+export async function fetchDeferred(
+	model: Model,
+	handle: DeferredHandle,
+	options: OperationOptions = {},
+): Promise<AssistantMessage> {
+	validateRoute(model, handle);
+	const response = await request(model, `/${encodeURIComponent(handle.id)}`, "GET", options);
+	if (response.id !== handle.id) throw new Error("Deferred response identity does not match its handle");
+	const output: AssistantMessage = {
+		role: "assistant",
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		responseId: response.id,
+		content: [],
+		stopReason: "stop",
+		timestamp: Date.now(),
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+	};
+	if (response.status === "queued" || response.status === "in_progress") {
+		output.deferred = handle;
+		return output;
+	}
+	if (response.status === "cancelled" || response.status === "failed") {
+		output.stopReason = "error";
+		output.errorMessage = `Deferred response ${response.status}`;
+		return output;
+	}
+	async function* events() {
+		for (const [output_index, item] of response.output.entries()) {
+			if (!item || typeof item !== "object" || typeof item.type !== "string")
+				throw new Error("Malformed deferred output item");
+			yield { type: "response.output_item.added", output_index, item };
+			yield { type: "response.output_item.done", output_index, item };
+		}
+		yield { type: response.status === "incomplete" ? "response.incomplete" : "response.completed", response };
+	}
+	const stream = new AssistantMessageEventStream();
+	try {
+		await processResponsesStream(
+			events() as AsyncIterable<import("openai").default.Responses.ResponseStreamEvent>,
+			output,
+			stream,
+			model,
+			{
+				signal: options.signal,
+				grammarToolInputProperties: new Map(
+					(handle.data as { grammarTools?: [string, string][] } | undefined)?.grammarTools ?? [],
+				),
+			},
+		);
+	} finally {
+		stream.end(output);
+	}
+	output.providerPayload = createOpenAIResponsesHistoryPayload(model.provider, response.output);
+	return output;
+}
+export async function cancelDeferred(
+	model: Model,
+	handle: DeferredHandle,
+	options: OperationOptions = {},
+): Promise<void> {
+	validateRoute(model, handle);
+	const response = await request(model, `/${encodeURIComponent(handle.id)}/cancel`, "POST", options);
+	if (response.id !== handle.id) throw new Error("Deferred cancellation identity does not match its handle");
+}

package/src/index.ts

@@ -3,10 +3,13 @@ export { Type } from "@sinclair/typebox";
 export * from "./api-registry";
 export * from "./auth-storage";
 export * from "./codex-model-interaction";
+export * from "./deferred";
 export * from "./model-cache";
 export * from "./model-manager";
 export * from "./model-thinking";
 export * from "./models";
+export * from "./operation-catalog";
+export * from "./operations";
 export * from "./provider-details";
 export * from "./provider-models";
 export * from "./providers/anthropic";

package/src/model-cache.ts

@@ -4,7 +4,7 @@
  */
 import { Database } from "bun:sqlite";
 import { getModelDbPath } from "@f5-sales-demo/pi-utils";
-import type { Api, Model } from "./types";
+import type { AnyModel, Api, Model } from "./types";
 
 const CACHE_SCHEMA_VERSION = 2;
 
@@ -95,3 +95,36 @@ export function writeModelCache<TApi extends Api>(
 		// Cache writes are best-effort; failures should not break model resolution.
 	}
 }
+
+/** Operation catalogs share atomic storage but use distinct rows from chat discovery. */
+export function readOperationModelCache(provider: string, dbPath: string): AnyModel[] | undefined {
+	try {
+		const row = getDb(dbPath)
+			.query<CacheRow, [string]>("SELECT * FROM model_cache WHERE provider_id = ?")
+			.get(`operations:${provider}`);
+		if (!row || row.version !== CACHE_SCHEMA_VERSION) return undefined;
+		const models: unknown = JSON.parse(row.models);
+		if (
+			!Array.isArray(models) ||
+			!models.every(
+				model =>
+					model?.provider === provider &&
+					["image", "classifier"].includes(model.type) &&
+					typeof model.id === "string" &&
+					typeof model.api === "string" &&
+					typeof model.baseUrl === "string",
+			)
+		)
+			return undefined;
+		return models;
+	} catch {
+		return undefined;
+	}
+}
+
+export function writeOperationModelCache(provider: string, models: readonly AnyModel[], dbPath: string): void {
+	getDb(dbPath).run(
+		"INSERT OR REPLACE INTO model_cache (provider_id, version, updated_at, authoritative, models) VALUES (?, ?, ?, ?, ?)",
+		[`operations:${provider}`, CACHE_SCHEMA_VERSION, Date.now(), 1, JSON.stringify(models)],
+	);
+}

package/src/model-manager.ts

@@ -1,5 +1,5 @@
 import { readModelCache, writeModelCache } from "./model-cache";
-import { enrichModelThinking } from "./model-thinking";
+import { applyGeneratedModelPolicies, enrichModelThinking } from "./model-thinking";
 import { type GeneratedProvider, getBundledModels } from "./models";
 import type { Api, Model, Provider } from "./types";
 import { isRecord } from "./utils";
@@ -17,7 +17,7 @@ export type ModelRefreshStrategy = "online" | "offline" | "online-if-uncached";
  */
 export interface ModelsDevFallback<TApi extends Api = Api, TPayload = unknown> {
 	/** Fetches raw fallback payload (for example from models.dev). */
-	fetch(): Promise<TPayload>;
+	fetch(signal?: AbortSignal): Promise<TPayload>;
 	/** Maps payload into provider models. */
 	map(payload: TPayload, providerId: Provider): readonly Model<TApi>[];
 }
@@ -35,7 +35,7 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
 	/** Maximum cache age in milliseconds before considered stale. Default: 24h. */
 	cacheTtlMs?: number;
 	/** Optional dynamic endpoint fetcher. */
-	fetchDynamicModels?: () => Promise<readonly Model<TApi>[] | null>;
+	fetchDynamicModels?: (signal?: AbortSignal) => Promise<readonly Model<TApi>[] | null>;
 	/** Optional models.dev fallback hook. */
 	modelsDev?: ModelsDevFallback<TApi, TModelsDevPayload>;
 	/** Clock override for deterministic tests. */
@@ -59,7 +59,7 @@ export interface ModelResolutionResult<TApi extends Api = Api> {
  * Stateful facade over provider model resolution.
  */
 export interface ModelManager<TApi extends Api = Api> {
-	refresh(strategy?: ModelRefreshStrategy): Promise<ModelResolutionResult<TApi>>;
+	refresh(strategy?: ModelRefreshStrategy, options?: { signal?: AbortSignal }): Promise<ModelResolutionResult<TApi>>;
 }
 
 /**
@@ -68,9 +68,14 @@ export interface ModelManager<TApi extends Api = Api> {
 export function createModelManager<TApi extends Api = Api, TModelsDevPayload = unknown>(
 	options: ModelManagerOptions<TApi, TModelsDevPayload>,
 ): ModelManager<TApi> {
+	let generation = 0;
 	return {
-		refresh(strategy: ModelRefreshStrategy = "online-if-uncached") {
-			return resolveProviderModels(options, strategy);
+		refresh(strategy: ModelRefreshStrategy = "online-if-uncached", request?: { signal?: AbortSignal }) {
+			const revision = ++generation;
+			return resolveProviderModels(options, strategy, {
+				signal: request?.signal,
+				isCurrent: () => generation === revision,
+			});
 		},
 	};
 }
@@ -84,7 +89,9 @@ export function createModelManager<TApi extends Api = Api, TModelsDevPayload = u
 export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPayload = unknown>(
 	options: ModelManagerOptions<TApi, TModelsDevPayload>,
 	strategy: ModelRefreshStrategy = "online-if-uncached",
+	request?: { signal?: AbortSignal; isCurrent?: () => boolean },
 ): Promise<ModelResolutionResult<TApi>> {
+	request?.signal?.throwIfAborted();
 	const now = options.now ?? Date.now;
 	const ttlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
 	const dbPath = options.cacheDbPath;
@@ -103,8 +110,13 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 		cacheAgeMs,
 	);
 	const [fetchedModelsDevModels, fetchedDynamicModels] = shouldFetchFromNetwork
-		? await Promise.all([fetchModelsDev(options), dynamicFetcher ? fetchDynamicModels(dynamicFetcher) : null])
+		? await Promise.all([
+				fetchModelsDev(options, request?.signal),
+				dynamicFetcher ? fetchDynamicModels(() => dynamicFetcher(request?.signal)) : null,
+			])
 		: [null, null];
+	request?.signal?.throwIfAborted();
+	if (request?.isCurrent && !request.isCurrent()) throw new Error("Model refresh was superseded");
 	const modelsDevModels = normalizeModelList<TApi>(fetchedModelsDevModels ?? []);
 	const shouldUseFreshCacheAsAuthoritative =
 		strategy === "online-if-uncached" && (cache?.fresh ?? false) && hasAuthoritativeCache;
@@ -142,13 +154,14 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 
 async function fetchModelsDev<TApi extends Api, TModelsDevPayload>(
 	options: ModelManagerOptions<TApi, TModelsDevPayload>,
+	signal?: AbortSignal,
 ): Promise<Model<TApi>[] | null> {
 	if (!options.modelsDev) {
 		return null;
 	}
 
 	try {
-		const payload = await options.modelsDev.fetch();
+		const payload = await options.modelsDev.fetch(signal);
 		return normalizeModelList<TApi>(options.modelsDev.map(payload, options.providerId));
 	} catch {
 		return null;
@@ -234,10 +247,12 @@ function mergeDynamicModel<TApi extends Api>(existingModel: Model<TApi>, dynamic
 		reasoning: existingModel.reasoning || dynamicModel.reasoning,
 		input: supportsImage ? ["text", "image"] : ["text"],
 		cost: {
+			pricingKnown: dynamicModel.cost.pricingKnown ?? existingModel.cost.pricingKnown,
 			input: preferDiscoveryCost(dynamicModel.cost.input, existingModel.cost.input),
 			output: preferDiscoveryCost(dynamicModel.cost.output, existingModel.cost.output),
 			cacheRead: preferDiscoveryCost(dynamicModel.cost.cacheRead, existingModel.cost.cacheRead),
 			cacheWrite: preferDiscoveryCost(dynamicModel.cost.cacheWrite, existingModel.cost.cacheWrite),
+			tiers: dynamicModel.cost.tiers ?? existingModel.cost.tiers,
 		},
 		contextWindow: preferDiscoveryLimit(dynamicModel.contextWindow, existingModel.contextWindow),
 		maxTokens: preferDiscoveryLimit(dynamicModel.maxTokens, existingModel.maxTokens),
@@ -282,7 +297,10 @@ function normalizeModelList<TApi extends Api>(value: unknown): Model<TApi>[] {
 	const models: Model<TApi>[] = [];
 	for (const item of value) {
 		if (isModelLike(item)) {
-			models.push(enrichModelThinking(item as Model<TApi>));
+			const model = enrichModelThinking({ ...item } as Model<TApi>);
+			const normalized = [model];
+			applyGeneratedModelPolicies(normalized, { preserveDiscoveredThinking: true });
+			models.push(normalized[0]!);
 		}
 	}
 	return models;

package/src/model-thinking.ts

@@ -1,4 +1,6 @@
+import { enrichCloudflareModel } from "./providers/cloudflare-route";
 import { resolveOpenAICompat } from "./providers/openai-completions-compat";
+import { SOL_API_COST, SOL_API_THINKING, SOL_MODEL_ID } from "./sol-model";
 import type { Api, Model as ApiModel, ThinkingConfig } from "./types";
 
 /**
@@ -210,6 +212,14 @@ export const CLOUDFLARE_FALLBACK_MODEL: ApiModel<"anthropic-messages"> = {
  * trust `model.thinking` and avoid inferring capabilities on demand.
  */
 export function enrichModelThinking<TApi extends Api>(model: ApiModel<TApi>): ApiModel<TApi> {
+	model = enrichCloudflareModel(model);
+	if (
+		model.provider === "baseten" &&
+		["zai-org/GLM-5.2", "zai-org/GLM-5.2-Fast", "moonshotai/Kimi-K2.6"].includes(model.id)
+	) {
+		model = { ...model };
+		applyGeneratedModelPolicy(model);
+	}
 	const normalizedThinking = normalizeThinkingConfig(model.thinking);
 	if (!model.reasoning) {
 		return normalizedThinking === undefined && model.thinking === undefined
@@ -253,11 +263,12 @@ export function applyGeneratedModelPolicies(
 		// Subscription discovery is authoritative for the effort enum. Re-inferring
 		// it from a model family can add values rejected by the backing model.
 		const model =
-			options.preserveDiscoveredThinking && source.api === "openai-codex-responses"
+			options.preserveDiscoveredThinking &&
+			(source.api === "openai-codex-responses" || source.thinking !== undefined)
 				? enrichModelThinking(source)
 				: refreshModelThinking(source);
 		applyGeneratedModelPolicy(model);
-		models[index] = model;
+		models[index] = enrichCloudflareModel(model);
 	}
 }
 
@@ -402,6 +413,66 @@ export function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(
 }
 
 function applyGeneratedModelPolicy(model: ApiModel<Api>): void {
+	if (model.provider === "fireworks") {
+		const completion = model.id.includes("glm-") || model.id.includes("kimi-k3");
+		model.api = completion ? "openai-completions" : "anthropic-messages";
+		model.baseUrl = model.baseUrl.replace(/\/v1\/?$/, "") + (completion ? "/v1" : "");
+		model.compat = {
+			...model.compat,
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			sendSessionAffinityHeaders: true,
+			...(!completion ? { allowEmptySignature: true, supportsCacheControlOnTools: false } : {}),
+		} as ApiModel<Api>["compat"];
+		if (!completion && model.compat?.forceAdaptiveThinking && model.thinking)
+			model.thinking = { ...model.thinking, mode: "anthropic-adaptive" };
+	}
+	if (model.provider === "xai") model.api = "openai-responses";
+	if (model.provider === "xiaomi" && /api\.xiaomimimo\.com/.test(model.baseUrl)) {
+		model.api = "openai-completions";
+		model.baseUrl = model.baseUrl.replace(/\/anthropic\/?$/, "/v1");
+	}
+	if (
+		model.provider === "baseten" &&
+		["zai-org/GLM-5.2", "zai-org/GLM-5.2-Fast", "moonshotai/Kimi-K2.6"].includes(model.id)
+	) {
+		const glm = model.id.startsWith("zai-org/GLM-5.2");
+		model.compat = {
+			...model.compat,
+			thinkingFormat: "baseten",
+			supportsReasoningEffort: glm,
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			maxTokensField: "max_tokens",
+			sendSessionAffinityHeaders: true,
+			chatTemplateArgs: { enable_thinking: { $var: "thinking.enabled" } },
+		} as ApiModel<Api>["compat"];
+		model.thinking = {
+			mode: "effort",
+			defaultLevel: "high",
+			supportedLevels: (glm ? [Effort.High, Effort.Max] : [Effort.High]).map(effort => ({
+				effort,
+				description: EFFORT_DESCRIPTIONS[effort],
+			})),
+		};
+		if (glm) model.input = ["text"];
+	}
+	if (model.provider === "ant-ling" && model.id.startsWith("Ring-")) {
+		model.thinking = {
+			mode: "effort",
+			defaultLevel: "high",
+			supportedLevels: [
+				{ effort: "high", description: "Deep reasoning" },
+				{ effort: "xhigh", description: "Very deep reasoning" },
+			],
+		};
+		model.compat = {
+			...model.compat,
+			thinkingFormat: "ant-ling",
+			supportsReasoningEffort: false,
+		} as ApiModel<Api>["compat"];
+	}
+	if (model.provider === "mistral") model.api = "mistral-conversations";
 	const parsedModel = parseKnownModel(model.id);
 	if (parsedModel.family === "anthropic") {
 		applyAnthropicCatalogPolicy(model, parsedModel);
@@ -435,6 +506,26 @@ function applyAnthropicCatalogPolicy(model: ApiModel<Api>, parsedModel: Anthropi
 }
 
 function applyOpenAICatalogPolicy(model: ApiModel<Api>, parsedModel: OpenAIModel): void {
+	if (model.id === SOL_MODEL_ID) {
+		model.name = "GPT-6.1 Sol";
+		if (model.provider === "openai")
+			model.compat = {
+				supportsExplicitPromptCacheMode: true,
+				supportsAdditionalTools: true,
+				supportsToolSearch: true,
+				supportsOpenAIGrammarTools: true,
+				supportsCachedReasoningUpdates: true,
+				...model.compat,
+			} as ApiModel<Api>["compat"];
+		model.input = ["text", "image"];
+		model.maxInputTokens = Math.min(model.maxInputTokens ?? 922_000, 922_000);
+		model.maxTokens = Math.min(model.maxTokens, 128_000);
+		if (model.provider === "openai") {
+			model.api = "openai-responses";
+			model.contextWindow = 1_050_000;
+			model.cost = SOL_API_COST;
+		}
+	}
 	// The ChatGPT Codex subscription transport defaults to the lower-cost
 	// short-context tier. The coding-agent registry can opt Luna and Sol into
 	// their full published window without changing generated catalog defaults.
@@ -549,6 +640,7 @@ function inferOpenAISupportedEfforts<TApi extends Api>(
 	model: OpenAIModel,
 	catalogModel: ApiModel<TApi>,
 ): readonly ReasoningEffort[] {
+	if (catalogModel.id === SOL_MODEL_ID) return SOL_API_THINKING.supportedLevels.map(level => level.effort);
 	if (semverGte(model.version, "5.6") && catalogModel.api === "openai-codex-responses") {
 		return [ReasoningEffort.None, Effort.Low, Effort.Medium, Effort.High, Effort.XHigh, Effort.Max];
 	}