@oh-my-pi/pi-catalog 16.0.0 → 16.0.2

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [16.0.2] - 2026-06-16
+
+### Fixed
+
+- Fixed Kimi output caps for Umans AI Coding Plan and Venice so discovery metadata cannot use context-sized token ceilings as request caps.
+- Marked Umans Anthropic-compatible models as client-tool escaped so cached and bundled metadata do not expose `web_search` as a provider server tool.
+
+## [16.0.1] - 2026-06-15
+
+### Added
+
+- Added the Umans AI Coding Plan provider catalog with Anthropic-compatible model metadata and dynamic discovery ([#2636](https://github.com/can1357/oh-my-pi/pull/2636) by [@oldschoola](https://github.com/oldschoola)).
+
 ## [16.0.0] - 2026-06-15
 
 ### Breaking Changes

package/dist/types/hosts.d.ts

@@ -65,6 +65,10 @@ export declare const KNOWN_HOSTS: {
         readonly providers: readonly ["alibaba-coding-plan"];
         readonly urlMarkers: readonly ["dashscope"];
     };
+    readonly umans: {
+        readonly providers: readonly ["umans"];
+        readonly urlMarkers: readonly ["api.code.umans.ai"];
+    };
     readonly xiaomi: {
         readonly providers: readonly ["xiaomi"];
         readonly providerPrefixes: readonly ["xiaomi-token-plan-"];

package/dist/types/provider-models/descriptors.d.ts

@@ -272,6 +272,16 @@ export declare const CATALOG_PROVIDERS: readonly [{
     readonly catalogDiscovery: {
         readonly label: "Together";
     };
+}, {
+    readonly id: "umans";
+    readonly defaultModel: "umans-coder";
+    readonly envVars: readonly ["UMANS_AI_CODING_PLAN_API_KEY"];
+    readonly createModelManagerOptions: (config: ModelManagerConfig) => import("..").ModelManagerOptions<"anthropic-messages", unknown>;
+    readonly dynamicModelsAuthoritative: true;
+    readonly catalogDiscovery: {
+        readonly label: "Umans AI Coding Plan";
+        readonly allowUnauthenticated: true;
+    };
 }, {
     readonly id: "venice";
     readonly defaultModel: "llama-3.3-70b";

package/dist/types/provider-models/openai-compat.d.ts

@@ -40,6 +40,12 @@ type SimpleProviderConfig = {
     fetch?: FetchImpl;
 };
 export declare function createSimpleOpenAICompletionsOptions(providerId: Parameters<typeof getBundledModels>[0], defaultBaseUrl: string, config?: SimpleProviderConfig): ModelManagerOptions<"openai-completions">;
+export interface UmansModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchImpl;
+}
+export declare function umansModelManagerOptions(config?: UmansModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
 export interface OpenAIModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
@@ -166,6 +172,14 @@ export declare function isFireworksKimiK2ModelId(modelId: string): boolean;
  */
 export declare function clampFireworksKimiMaxTokens(modelId: string, candidate: number): number;
 export declare function clampFireworksKimiMaxTokens(modelId: string, candidate: number | null): number | null;
+/**
+ * Kimi K2.7 Code's documented recommended output budget. Some provider
+ * discovery rows report the context-sized `max_completion_tokens` instead.
+ */
+export declare const KIMI_K27_CODE_RECOMMENDED_MAX_TOKENS = 32768;
+export declare function isKimiK27CodeModelId(modelId: string): boolean;
+export declare function clampKimiK27CodeMaxTokens(modelId: string, candidate: number): number;
+export declare function clampKimiK27CodeMaxTokens(modelId: string, candidate: number | null): number | null;
 /**
  * Fireworks DeepSeek V4 accepts effort via `reasoning_effort` but rejects the
  * DeepSeek-native binary `thinking` toggle when both are present.

package/dist/types/types.d.ts

@@ -285,6 +285,13 @@ export interface AnthropicCompat {
      * Default: auto-detected from provider/baseUrl and `model.reasoning`.
      */
     replayUnsignedThinking?: boolean;
+    /**
+     * Prefix Anthropic built-in tool names (`web_search`, `code_execution`, ...)
+     * when they are ordinary client tools. Some Anthropic-compatible gateways
+     * intercept those exact names as server tools and return raw search/result
+     * blocks instead of normal `tool_use` calls.
+     */
+    escapeBuiltinToolNames?: boolean;
 }
 /**
  * OpenRouter provider routing preferences.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "16.0.0",
+	"version": "16.0.2",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -34,11 +34,11 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-utils": "16.0.0",
+		"@oh-my-pi/pi-utils": "16.0.2",
 		"zod": "^4"
 	},
 	"devDependencies": {
-		"@oh-my-pi/pi-ai": "16.0.0",
+		"@oh-my-pi/pi-ai": "16.0.2",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/compat/anthropic.ts

@@ -67,6 +67,7 @@ export function buildAnthropicCompat(spec: ModelSpec<"anthropic-messages">): Res
 		// arguments (#2005). Known non-signing hosts (Z.AI, DeepSeek) are also
 		// preserved for compatibility.
 		replayUnsignedThinking: isZai || modelMatchesHost(spec, "deepseekFamily") || (spec.reasoning && !official),
+		escapeBuiltinToolNames: modelMatchesHost(spec, "umans"),
 	};
 	applyCompatOverrides(compat, spec.compat);
 	return compat;

package/src/hosts.ts

@@ -42,6 +42,7 @@ export const KNOWN_HOSTS = {
 	zhipu: { providers: ["zhipu-coding-plan"], urlMarkers: ["open.bigmodel.cn"] },
 	kilo: { providers: ["kilo"], urlMarkers: ["api.kilo.ai"] },
 	alibabaDashscope: { providers: ["alibaba-coding-plan"], urlMarkers: ["dashscope"] },
+	umans: { providers: ["umans"], urlMarkers: ["api.code.umans.ai"] },
 	xiaomi: { providers: ["xiaomi"], providerPrefixes: ["xiaomi-token-plan-"], urlMarkers: ["xiaomimimo.com"] },
 	xai: { providers: ["xai"], urlMarkers: ["api.x.ai"] },
 	mistral: { providers: ["mistral"], urlMarkers: ["mistral.ai"] },

package/src/identity/priority.ts

@@ -27,6 +27,7 @@ const DEFAULT_MODEL_PROVIDER_ORDER = [
 	// Generic gateways and editor/proxy providers. These are useful when picked
 	// explicitly, but should not win ambiguous automatic role selection.
 	"alibaba-coding-plan",
+	"umans",
 	"google-antigravity",
 	"opencode-zen",
 	"gitlab-duo",

package/src/models.json

@@ -60012,8 +60012,8 @@
 				"text"
 			],
 			"cost": {
-				"input": 0.09,
-				"output": 0.18,
+				"input": 0.098,
+				"output": 0.196,
 				"cacheRead": 0.02,
 				"cacheWrite": 0
 			},
@@ -65288,7 +65288,7 @@
 				"cacheWrite": 0
 			},
 			"contextWindow": 262144,
-			"maxTokens": 262144,
+			"maxTokens": 81920,
 			"thinking": {
 				"mode": "effort",
 				"efforts": [
@@ -65311,12 +65311,12 @@
 				"image"
 			],
 			"cost": {
-				"input": 0.39,
-				"output": 2.34,
+				"input": 0.385,
+				"output": 2.4499999999999997,
 				"cacheRead": 0.195,
 				"cacheWrite": 0
 			},
-			"contextWindow": 262144,
+			"contextWindow": 256000,
 			"maxTokens": 65536,
 			"thinking": {
 				"mode": "effort",
@@ -65932,13 +65932,13 @@
 				"text"
 			],
 			"cost": {
-				"input": 0.063,
-				"output": 0.21,
-				"cacheRead": 0.020999999999999998,
+				"input": 0.06599999999999999,
+				"output": 0.26,
+				"cacheRead": 0.029,
 				"cacheWrite": 0
 			},
 			"contextWindow": 262144,
-			"maxTokens": 64000,
+			"maxTokens": 262144,
 			"thinking": {
 				"mode": "effort",
 				"efforts": [
@@ -68887,6 +68887,207 @@
 			}
 		}
 	},
+	"umans": {
+		"umans-coder": {
+			"id": "umans-coder",
+			"name": "Umans Coder",
+			"api": "anthropic-messages",
+			"provider": "umans",
+			"baseUrl": "https://api.code.umans.ai",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 262144,
+			"maxTokens": 32768,
+			"thinking": {
+				"mode": "budget",
+				"efforts": [
+					"minimal",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			},
+			"compat": {
+				"escapeBuiltinToolNames": true
+			}
+		},
+		"umans-flash": {
+			"id": "umans-flash",
+			"name": "Umans Flash",
+			"api": "anthropic-messages",
+			"provider": "umans",
+			"baseUrl": "https://api.code.umans.ai",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 262144,
+			"maxTokens": 32768,
+			"thinking": {
+				"mode": "budget",
+				"efforts": [
+					"minimal",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			},
+			"compat": {
+				"escapeBuiltinToolNames": true
+			}
+		},
+		"umans-glm-5.1": {
+			"id": "umans-glm-5.1",
+			"name": "Umans GLM 5.1",
+			"api": "anthropic-messages",
+			"provider": "umans",
+			"baseUrl": "https://api.code.umans.ai",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 202752,
+			"maxTokens": 131072,
+			"thinking": {
+				"mode": "budget",
+				"efforts": [
+					"minimal",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			},
+			"compat": {
+				"escapeBuiltinToolNames": true
+			}
+		},
+		"umans-kimi-k2.6": {
+			"id": "umans-kimi-k2.6",
+			"name": "Umans Kimi K2.6",
+			"api": "anthropic-messages",
+			"provider": "umans",
+			"baseUrl": "https://api.code.umans.ai",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 262144,
+			"maxTokens": 32768,
+			"thinking": {
+				"mode": "budget",
+				"efforts": [
+					"minimal",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			},
+			"compat": {
+				"escapeBuiltinToolNames": true
+			}
+		},
+		"umans-kimi-k2.7": {
+			"id": "umans-kimi-k2.7",
+			"name": "Umans Kimi K2.7 Code",
+			"api": "anthropic-messages",
+			"provider": "umans",
+			"baseUrl": "https://api.code.umans.ai",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 262144,
+			"maxTokens": 32768,
+			"thinking": {
+				"mode": "budget",
+				"efforts": [
+					"minimal",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				],
+				"requiresEffort": true
+			},
+			"compat": {
+				"escapeBuiltinToolNames": true
+			}
+		},
+		"umans-qwen3.6-35b-a3b": {
+			"id": "umans-qwen3.6-35b-a3b",
+			"name": "Umans Qwen3.6 35B A3B",
+			"api": "anthropic-messages",
+			"provider": "umans",
+			"baseUrl": "https://api.code.umans.ai",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 262144,
+			"maxTokens": 32768,
+			"thinking": {
+				"mode": "budget",
+				"efforts": [
+					"minimal",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				]
+			},
+			"compat": {
+				"escapeBuiltinToolNames": true
+			}
+		}
+	},
 	"venice": {
 		"aion-labs-aion-2-0": {
 			"id": "aion-labs-aion-2-0",
@@ -70356,6 +70557,28 @@
 				]
 			}
 		},
+		"kimi-k2-7-code": {
+			"id": "kimi-k2-7-code",
+			"name": "kimi-k2-7-code",
+			"api": "openai-completions",
+			"provider": "venice",
+			"baseUrl": "https://api.venice.ai/api/v1",
+			"reasoning": false,
+			"input": [
+				"text"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 256000,
+			"maxTokens": 32768,
+			"compat": {
+				"supportsUsageInStreaming": false
+			}
+		},
 		"kimi-k2-thinking": {
 			"id": "kimi-k2-thinking",
 			"name": "Kimi K2 Thinking",
@@ -72105,7 +72328,8 @@
 				"supportsForcedToolChoice": true,
 				"supportsSamplingParams": true,
 				"requiresToolResultId": false,
-				"replayUnsignedThinking": false
+				"replayUnsignedThinking": false,
+				"escapeBuiltinToolNames": false
 			}
 		},
 		"alibaba/qwen3-max-preview": {

package/src/provider-models/descriptors.ts

@@ -37,6 +37,7 @@ import {
 	qwenPortalModelManagerOptions,
 	syntheticModelManagerOptions,
 	togetherModelManagerOptions,
+	umansModelManagerOptions,
 	veniceModelManagerOptions,
 	vercelAiGatewayModelManagerOptions,
 	vllmModelManagerOptions,
@@ -313,6 +314,14 @@ export const CATALOG_PROVIDERS = [
 		createModelManagerOptions: (config: ModelManagerConfig) => togetherModelManagerOptions(config),
 		catalogDiscovery: { label: "Together" },
 	},
+	{
+		id: "umans",
+		defaultModel: "umans-coder",
+		envVars: ["UMANS_AI_CODING_PLAN_API_KEY"],
+		createModelManagerOptions: (config: ModelManagerConfig) => umansModelManagerOptions(config),
+		dynamicModelsAuthoritative: true,
+		catalogDiscovery: { label: "Umans AI Coding Plan", allowUnauthenticated: true },
+	},
 	{
 		id: "venice",
 		defaultModel: "llama-3.3-70b",

package/src/provider-models/openai-compat.ts

@@ -568,6 +568,159 @@ function createSimpleAnthropicProviderOptions(
 	};
 }
 
+// ---------------------------------------------------------------------------
+// Umans AI Coding Plan
+// ---------------------------------------------------------------------------
+
+const UMANS_BASE_URL = "https://api.code.umans.ai";
+const UMANS_MODELS_INFO_PATH = "/models/info";
+const UMANS_REASONING_EFFORT_BY_LEVEL: Record<string, Effort> = {
+	minimal: Effort.Minimal,
+	low: Effort.Low,
+	medium: Effort.Medium,
+	high: Effort.High,
+	xhigh: Effort.XHigh,
+};
+const UMANS_DEFAULT_REASONING_EFFORTS = [Effort.Minimal, Effort.Low, Effort.Medium, Effort.High, Effort.XHigh] as const;
+
+export interface UmansModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: FetchImpl;
+}
+
+interface UmansModelInfo {
+	name?: unknown;
+	display_name?: unknown;
+	capabilities?: unknown;
+}
+
+function normalizeUmansBaseUrl(baseUrl: string | undefined): string {
+	const normalized = normalizeAnthropicBaseUrl(baseUrl, UMANS_BASE_URL);
+	return normalized.endsWith("/v1") ? normalized.slice(0, -3) : normalized;
+}
+
+function umansSupportsVision(value: unknown): boolean {
+	return value === true || (typeof value === "string" && value.length > 0);
+}
+
+function umansReasoningSupported(value: unknown): boolean {
+	return isRecord(value) ? value.supported === true : value === true;
+}
+
+function mapUmansReasoningEfforts(value: unknown): readonly Effort[] {
+	if (!isRecord(value) || !Array.isArray(value.levels)) {
+		return UMANS_DEFAULT_REASONING_EFFORTS;
+	}
+	const efforts: Effort[] = [];
+	for (const level of value.levels) {
+		if (typeof level !== "string") continue;
+		const effort = UMANS_REASONING_EFFORT_BY_LEVEL[level];
+		if (effort !== undefined && !efforts.includes(effort)) {
+			efforts.push(effort);
+		}
+	}
+	return efforts.length > 0 ? efforts : UMANS_DEFAULT_REASONING_EFFORTS;
+}
+
+function mapUmansThinkingConfig(value: unknown): ThinkingConfig | undefined {
+	if (!umansReasoningSupported(value)) return undefined;
+	const efforts = mapUmansReasoningEfforts(value);
+	const thinking: ThinkingConfig = { mode: "budget", efforts };
+	if (isRecord(value)) {
+		if (value.can_disable === false) {
+			thinking.requiresEffort = true;
+		}
+		if (typeof value.default_level === "string") {
+			const defaultLevel = UMANS_REASONING_EFFORT_BY_LEVEL[value.default_level];
+			if (defaultLevel !== undefined && efforts.includes(defaultLevel)) {
+				thinking.defaultLevel = defaultLevel;
+			}
+		}
+	}
+	return thinking;
+}
+
+function mapUmansModelInfo(
+	modelId: string,
+	raw: UmansModelInfo,
+	baseUrl: string,
+	reference: ModelSpec<"anthropic-messages"> | undefined,
+): ModelSpec<"anthropic-messages"> | null {
+	if (!modelId) return null;
+	const capabilities = isRecord(raw.capabilities) ? raw.capabilities : {};
+	const supportsTools = capabilities.supports_tools;
+	const thinking = mapUmansThinkingConfig(capabilities.reasoning);
+	return {
+		...reference,
+		id: modelId,
+		name: toModelName(raw.display_name, toModelName(raw.name, modelId)),
+		api: "anthropic-messages",
+		provider: "umans",
+		baseUrl,
+		compat: { ...reference?.compat, escapeBuiltinToolNames: true },
+		reasoning: thinking !== undefined,
+		...(thinking ? { thinking } : {}),
+		input: umansSupportsVision(capabilities.supports_vision) ? ["text", "image"] : ["text"],
+		...(supportsTools === false ? { supportsTools: false } : {}),
+		cost: reference?.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: toPositiveNumber(capabilities.context_window, reference?.contextWindow ?? null),
+		maxTokens: toPositiveNumber(
+			capabilities.recommended_max_tokens,
+			toPositiveNumber(capabilities.max_completion_tokens, reference?.maxTokens ?? null),
+		),
+	};
+}
+
+async function fetchUmansModelsInfo(options: {
+	baseUrl: string;
+	apiKey?: string;
+	fetch?: FetchImpl;
+	references: Map<string, ModelSpec<"anthropic-messages">>;
+}): Promise<ModelSpec<"anthropic-messages">[] | null> {
+	const discoveryBaseUrl = toAnthropicDiscoveryBaseUrl(options.baseUrl);
+	const requestHeaders: Record<string, string> = { Accept: "application/json" };
+	if (options.apiKey) {
+		requestHeaders["x-api-key"] = options.apiKey;
+	}
+	const fetchImpl = options.fetch ?? fetch;
+	let payload: unknown;
+	try {
+		const response = await fetchImpl(`${discoveryBaseUrl}${UMANS_MODELS_INFO_PATH}`, {
+			method: "GET",
+			headers: requestHeaders,
+		});
+		if (!response.ok) {
+			return null;
+		}
+		payload = await response.json();
+	} catch (error) {
+		throw new Error("Failed to fetch Umans models info", { cause: error });
+	}
+	if (!isRecord(payload)) {
+		return null;
+	}
+	const models: ModelSpec<"anthropic-messages">[] = [];
+	for (const [modelId, value] of Object.entries(payload)) {
+		if (!isRecord(value)) continue;
+		const mapped = mapUmansModelInfo(modelId, value, options.baseUrl, options.references.get(modelId));
+		if (mapped) {
+			models.push(mapped);
+		}
+	}
+	return models.sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export function umansModelManagerOptions(config?: UmansModelManagerConfig): ModelManagerOptions<"anthropic-messages"> {
+	const apiKey = config?.apiKey;
+	const baseUrl = normalizeUmansBaseUrl(config?.baseUrl);
+	const references = createBundledReferenceMap<"anthropic-messages">("umans");
+	return {
+		providerId: "umans",
+		dynamicModelsAuthoritative: true,
+		fetchDynamicModels: () => fetchUmansModelsInfo({ baseUrl, apiKey, fetch: config?.fetch, references }),
+	};
+}
 // ---------------------------------------------------------------------------
 // 1. OpenAI
 // ---------------------------------------------------------------------------
@@ -1083,6 +1236,23 @@ export function clampFireworksKimiMaxTokens(modelId: string, candidate: number |
 	return isFireworksKimiK2ModelId(modelId) ? Math.min(candidate, FIREWORKS_KIMI_MAX_TOKENS) : candidate;
 }
 
+/**
+ * Kimi K2.7 Code's documented recommended output budget. Some provider
+ * discovery rows report the context-sized `max_completion_tokens` instead.
+ */
+export const KIMI_K27_CODE_RECOMMENDED_MAX_TOKENS = 32_768;
+
+export function isKimiK27CodeModelId(modelId: string): boolean {
+	return /(?:^|\/)kimi[-._]?k2(?:[._-]?|p)7[-._]?code$/i.test(modelId);
+}
+
+export function clampKimiK27CodeMaxTokens(modelId: string, candidate: number): number;
+export function clampKimiK27CodeMaxTokens(modelId: string, candidate: number | null): number | null;
+export function clampKimiK27CodeMaxTokens(modelId: string, candidate: number | null): number | null {
+	if (candidate === null) return null;
+	return isKimiK27CodeModelId(modelId) ? Math.min(candidate, KIMI_K27_CODE_RECOMMENDED_MAX_TOKENS) : candidate;
+}
+
 /**
  * Fireworks DeepSeek V4 accepts effort via `reasoning_effort` but rejects the
  * DeepSeek-native binary `thinking` toggle when both are present.
@@ -2127,6 +2297,7 @@ export function veniceModelManagerOptions(
 					const model = mapWithBundledReference(entry, defaults, reference);
 					return {
 						...model,
+						maxTokens: clampKimiK27CodeMaxTokens(defaults.id, model.maxTokens),
 						compat: { ...model.compat, supportsUsageInStreaming: false },
 					};
 				},
@@ -2307,7 +2478,7 @@ export function xiaomiModelManagerOptions(
 			provider: providerId,
 			baseUrl: url,
 			apiKey,
-			filterModel: (_entry, model) => !model.id.includes("-tts"),
+			filterModel: (_entry, model) => !model.id.includes("-tts") && !model.id.includes("-asr"),
 			mapModel: (entry, defaults) => {
 				const reference = references.get(defaults.id);
 				const model = mapWithBundledReference(entry, defaults, reference);
@@ -3245,6 +3416,8 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_CORE: readonly ModelsDevProviderDescriptor
 const MODELS_DEV_PROVIDER_DESCRIPTORS_CODING_PLANS: readonly ModelsDevProviderDescriptor[] = [
 	// --- zAI ---
 	anthropicMessagesDescriptor("zai-coding-plan", "zai", "https://api.z.ai/api/anthropic"),
+	// --- Umans AI Coding Plan ---
+	anthropicMessagesDescriptor("umans-ai-coding-plan", "umans", UMANS_BASE_URL),
 	// --- Xiaomi ---
 	openAiCompletionsDescriptor("xiaomi", "xiaomi", "https://api.xiaomimimo.com/v1", {
 		defaultContextWindow: 262144,
@@ -3393,7 +3566,12 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_SPECIALIZED: readonly ModelsDevProviderDes
 	// --- Synthetic ---
 	openAiCompletionsDescriptor("synthetic", "synthetic", "https://api.synthetic.new/openai/v1"),
 	// --- Venice AI ---
-	openAiCompletionsDescriptor("venice", "venice", "https://api.venice.ai/api/v1"),
+	openAiCompletionsDescriptor("venice", "venice", "https://api.venice.ai/api/v1", {
+		transformModel: model => {
+			const maxTokens = clampKimiK27CodeMaxTokens(model.id, model.maxTokens);
+			return maxTokens === model.maxTokens ? model : { ...model, maxTokens };
+		},
+	}),
 	// --- Ollama Cloud ---
 	simpleModelsDevDescriptor("ollama-cloud", "ollama-cloud", "ollama-chat", "https://ollama.com"),
 	// --- Xiaomi Token Plan ---

package/src/types.ts

@@ -311,6 +311,13 @@ export interface AnthropicCompat {
 	 * Default: auto-detected from provider/baseUrl and `model.reasoning`.
 	 */
 	replayUnsignedThinking?: boolean;
+	/**
+	 * Prefix Anthropic built-in tool names (`web_search`, `code_execution`, ...)
+	 * when they are ordinary client tools. Some Anthropic-compatible gateways
+	 * intercept those exact names as server tools and return raw search/result
+	 * blocks instead of normal `tool_use` calls.
+	 */
+	escapeBuiltinToolNames?: boolean;
 }
 
 /**