@sayknow-cli/ai 0.2.4 → 0.2.5

package/src/models.ts

@@ -33,14 +33,21 @@ function getProviderModels(provider: GeneratedProvider): Map<string, Model<Api>>
  * Mythos rejecting forced tool use) without a full regeneration.
  */
 function applyBundledCompatDefaults(model: Model<Api>): Model<Api> {
+	let normalized = model;
+	if (normalized.id === "minimax-m3" && normalized.name === "MiniMax M3") {
+		normalized = { ...normalized, name: "MiniMax-M3" };
+	}
 	if (
-		(model.api === "anthropic-messages" || model.api === "bedrock-converse-stream") &&
-		isClaudeForcedToolChoiceIncapableModelId(model.id) &&
-		(model.compat as { toolChoiceSupport?: string } | undefined)?.toolChoiceSupport === undefined
+		(normalized.api === "anthropic-messages" || normalized.api === "bedrock-converse-stream") &&
+		isClaudeForcedToolChoiceIncapableModelId(normalized.id) &&
+		(normalized.compat as { toolChoiceSupport?: string } | undefined)?.toolChoiceSupport === undefined
 	) {
-		return { ...model, compat: { ...(model.compat ?? {}), toolChoiceSupport: "auto" } as Model<Api>["compat"] };
+		return {
+			...normalized,
+			compat: { ...(normalized.compat ?? {}), toolChoiceSupport: "auto" } as Model<Api>["compat"],
+		};
 	}
-	return model;
+	return normalized;
 }
 
 export type GeneratedProvider = keyof typeof MODELS;

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

@@ -176,6 +176,57 @@ function mapWithBundledReference<TApi extends Api>(
 	};
 }
 
+function getNestedModelValue(entry: OpenAICompatibleModelRecord, path: readonly string[]): unknown {
+	let current: unknown = entry;
+	for (const segment of path) {
+		if (!isRecord(current)) {
+			return undefined;
+		}
+		current = current[segment];
+	}
+	return current;
+}
+
+function firstPositiveModelNumber(fallback: number, ...candidates: readonly unknown[]): number {
+	for (const candidate of candidates) {
+		const value = toNumber(candidate);
+		if (value !== undefined && value > 0) {
+			return value;
+		}
+	}
+	return fallback;
+}
+
+function mapLmStudioModel(
+	entry: OpenAICompatibleModelRecord,
+	defaults: Model<"openai-completions">,
+	reference: Model<"openai-completions"> | undefined,
+): Model<"openai-completions"> {
+	const model = mapWithBundledReference(entry, defaults, reference);
+	return {
+		...model,
+		contextWindow: firstPositiveModelNumber(
+			model.contextWindow,
+			entry.context_length,
+			entry.max_context_length,
+			getNestedModelValue(entry, ["meta", "n_ctx"]),
+			getNestedModelValue(entry, ["details", "context_length"]),
+			getNestedModelValue(entry, ["details", "n_ctx"]),
+			getNestedModelValue(entry, ["meta", "n_ctx_train"]),
+		),
+		maxTokens: firstPositiveModelNumber(
+			model.maxTokens,
+			entry.max_completion_tokens,
+			entry.max_tokens,
+			entry.max_output_tokens,
+			getNestedModelValue(entry, ["details", "max_completion_tokens"]),
+			getNestedModelValue(entry, ["details", "max_tokens"]),
+			getNestedModelValue(entry, ["meta", "max_completion_tokens"]),
+			getNestedModelValue(entry, ["meta", "max_tokens"]),
+		),
+	};
+}
+
 function normalizeAnthropicBaseUrl(baseUrl: string | undefined, fallback: string): string {
 	const value = baseUrl?.trim();
 	if (!value) {
@@ -761,6 +812,8 @@ function openCodeModelManagerOptions(
 ): ModelManagerOptions<"openai-completions"> {
 	const apiKey = config?.apiKey;
 	const baseUrl = config?.baseUrl ?? defaultBaseUrl;
+	const references =
+		providerId === "opencode-go" ? createBundledReferenceMap<"openai-completions">(providerId) : undefined;
 	return {
 		providerId,
 		...(apiKey && {
@@ -770,6 +823,13 @@ function openCodeModelManagerOptions(
 					provider: providerId,
 					baseUrl,
 					apiKey,
+					...(providerId === "opencode-go" && {
+						mapModel: (entry, defaults) => {
+							const reference = references?.get(defaults.id);
+							const model = mapWithBundledReference(entry, defaults, reference);
+							return applyOpenCodeGoOfficialMetadata(model);
+						},
+					}),
 				}),
 		}),
 	};
@@ -1215,7 +1275,7 @@ export function lmStudioModelManagerOptions(
 				apiKey,
 				mapModel: (entry, defaults) => {
 					const reference = references.get(defaults.id);
-					return mapWithBundledReference(entry, defaults, reference);
+					return mapLmStudioModel(entry, defaults, reference);
 				},
 			}),
 	};
@@ -1870,6 +1930,8 @@ export interface ModelsDevProviderDescriptor {
 	 * Can return null to skip the model, or an array to emit multiple models.
 	 */
 	transformModel?: (model: Model<Api>, modelId: string, raw: ModelsDevModel) => Model<Api> | Model<Api>[] | null;
+	/** Optional static rows appended after mapped models. Used only for official provider catalogs missing from models.dev. */
+	appendModels?: readonly Model<Api>[];
 	/**
 	 * Optional: override the API type per-model.
 	 * Called with (modelId, raw). Return the API type to use.
@@ -1886,56 +1948,59 @@ export function mapModelsDevToModels(
 	const models: Model<Api>[] = [];
 	for (const desc of descriptors) {
 		const providerData = (data as Record<string, Record<string, unknown>>)[desc.modelsDevKey];
-		if (!isRecord(providerData) || !isRecord(providerData.models)) continue;
-
-		for (const [modelId, rawModel] of Object.entries(providerData.models)) {
-			if (!isRecord(rawModel)) continue;
-			const m = rawModel as ModelsDevModel;
-
-			// Default filter: tool_call must be true
-			if (desc.filterModel) {
-				if (!desc.filterModel(modelId, m)) continue;
-			} else {
-				if (m.tool_call !== true) continue;
-			}
+		if (isRecord(providerData) && isRecord(providerData.models)) {
+			for (const [modelId, rawModel] of Object.entries(providerData.models)) {
+				if (!isRecord(rawModel)) continue;
+				const m = rawModel as ModelsDevModel;
+
+				// Default filter: tool_call must be true
+				if (desc.filterModel) {
+					if (!desc.filterModel(modelId, m)) continue;
+				} else {
+					if (m.tool_call !== true) continue;
+				}
 
-			// Resolve API and baseUrl (may be per-model for providers like OpenCode)
-			const resolved = desc.resolveApi?.(modelId, m) ?? { api: desc.api, baseUrl: desc.baseUrl };
-			if (!resolved) continue;
-
-			const mapped: Model<Api> = {
-				id: modelId,
-				name: toModelName(m.name, modelId),
-				api: resolved.api,
-				provider: desc.providerId as Model<Api>["provider"],
-				baseUrl: resolved.baseUrl,
-				reasoning: m.reasoning === true,
-				input: toInputCapabilities(m.modalities?.input),
-				cost: {
-					input: toNumber(m.cost?.input) ?? 0,
-					output: toNumber(m.cost?.output) ?? 0,
-					cacheRead: toNumber(m.cost?.cache_read) ?? 0,
-					cacheWrite: toNumber(m.cost?.cache_write) ?? 0,
-				},
-				contextWindow: toPositiveNumber(m.limit?.context, desc.defaultContextWindow ?? UNK_CONTEXT_WINDOW),
-				maxTokens: toPositiveNumber(m.limit?.output, desc.defaultMaxTokens ?? UNK_MAX_TOKENS),
-				...(desc.compat && { compat: desc.compat }),
-				...(desc.headers && { headers: { ...desc.headers } }),
-			};
+				// Resolve API and baseUrl (may be per-model for providers like OpenCode)
+				const resolved = desc.resolveApi?.(modelId, m) ?? { api: desc.api, baseUrl: desc.baseUrl };
+				if (!resolved) continue;
+
+				const mapped: Model<Api> = {
+					id: modelId,
+					name: toModelName(m.name, modelId),
+					api: resolved.api,
+					provider: desc.providerId as Model<Api>["provider"],
+					baseUrl: resolved.baseUrl,
+					reasoning: m.reasoning === true,
+					input: toInputCapabilities(m.modalities?.input),
+					cost: {
+						input: toNumber(m.cost?.input) ?? 0,
+						output: toNumber(m.cost?.output) ?? 0,
+						cacheRead: toNumber(m.cost?.cache_read) ?? 0,
+						cacheWrite: toNumber(m.cost?.cache_write) ?? 0,
+					},
+					contextWindow: toPositiveNumber(m.limit?.context, desc.defaultContextWindow ?? UNK_CONTEXT_WINDOW),
+					maxTokens: toPositiveNumber(m.limit?.output, desc.defaultMaxTokens ?? UNK_MAX_TOKENS),
+					...(desc.compat && { compat: desc.compat }),
+					...(desc.headers && { headers: { ...desc.headers } }),
+				};
 
-			// Apply per-model transform
-			if (desc.transformModel) {
-				const result = desc.transformModel(mapped, modelId, m);
-				if (result === null) continue;
-				if (Array.isArray(result)) {
-					models.push(...result);
+				// Apply per-model transform
+				if (desc.transformModel) {
+					const result = desc.transformModel(mapped, modelId, m);
+					if (result === null) continue;
+					if (Array.isArray(result)) {
+						models.push(...result);
+					} else {
+						models.push(result);
+					}
 				} else {
-					models.push(result);
+					models.push(mapped);
 				}
-			} else {
-				models.push(mapped);
 			}
 		}
+		if (desc.appendModels) {
+			models.push(...desc.appendModels);
+		}
 	}
 	return models;
 }
@@ -2025,22 +2090,35 @@ function createOpenCodeApiResolution(
 	};
 }
 
+const OPENCODE_GO_BASE_PATH = "https://opencode.ai/zen/go";
 const OPENCODE_ZEN_API_RESOLUTION = createOpenCodeApiResolution("https://opencode.ai/zen");
-// OpenCode Go: models.dev declares minimax-m2.7 / qwen3.5-plus / qwen3.6-plus
-// with `provider.npm = "@ai-sdk/anthropic"`, but the OpenCode Go gateway only
-// serves them at `https://opencode.ai/zen/go/v1/chat/completions` (verified
-// against https://opencode.ai/zen/go/v1/models and the upstream endpoint
-// table at https://opencode.ai/docs/go/#endpoints — minimax-m2.5 works the
-// same way and lacks an `npm` field on models.dev so it already falls through
-// to the openai-completions default). Without this override the resolver
-// would POST anthropic-style requests to /v1/messages and the gateway would
-// return its `Page Not Found` HTML (issue #887). Override the resolver so
-// regenerating models.json keeps the correct routing.
-const OPENCODE_GO_API_RESOLUTION = createOpenCodeApiResolution("https://opencode.ai/zen/go", {
-	"minimax-m2.7": "openai-completions",
-	"qwen3.5-plus": "openai-completions",
-	"qwen3.6-plus": "openai-completions",
-});
+const OPENCODE_GO_CHAT_COMPLETIONS_MODEL_IDS = [
+	"deepseek-v4-flash",
+	"deepseek-v4-pro",
+	"glm-5.1",
+	"glm-5.2",
+	"kimi-k2.6",
+	"kimi-k2.7-code",
+	"mimo-v2.5",
+	"mimo-v2.5-pro",
+] as const;
+const OPENCODE_GO_MESSAGES_MODEL_IDS = [
+	"minimax-m2.5",
+	"minimax-m2.7",
+	"minimax-m3",
+	"qwen3.6-plus",
+	"qwen3.7-max",
+	"qwen3.7-plus",
+] as const;
+const OPENCODE_GO_API_OVERRIDES: Readonly<Record<string, Api>> = {
+	...Object.fromEntries(OPENCODE_GO_CHAT_COMPLETIONS_MODEL_IDS.map(id => [id, "openai-completions"])),
+	...Object.fromEntries(OPENCODE_GO_MESSAGES_MODEL_IDS.map(id => [id, "anthropic-messages"])),
+} as Record<string, Api>;
+// OpenCode Go has a provider-specific endpoint table at
+// https://opencode.ai/docs/go/#endpoints. Keep routing aligned with that table:
+// GLM/Kimi/DeepSeek/MiMo rows use /v1/chat/completions, while MiniMax and
+// current Qwen Plus/Max rows use /v1/messages via the Anthropic client.
+const OPENCODE_GO_API_RESOLUTION = createOpenCodeApiResolution(OPENCODE_GO_BASE_PATH, OPENCODE_GO_API_OVERRIDES);
 
 const COPILOT_BASE_URL = "https://api.githubcopilot.com";
 
@@ -2269,6 +2347,215 @@ const filterActiveToolCallModels = (_id: string, m: ModelsDevModel): boolean =>
 	return true;
 };
 
+interface OpenCodeGoOfficialModelMetadata {
+	name: string;
+	contextWindow: number;
+	maxTokens: number;
+	input: ("text" | "image")[];
+	reasoning: boolean;
+	cost: Model["cost"];
+}
+
+const OPENCODE_GO_OFFICIAL_MODELS: Readonly<Record<string, OpenCodeGoOfficialModelMetadata>> = {
+	"deepseek-v4-flash": {
+		name: "DeepSeek V4 Flash",
+		contextWindow: 1_000_000,
+		maxTokens: 384_000,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 0.14, output: 0.28, cacheRead: 0.0028, cacheWrite: 0 },
+	},
+	"deepseek-v4-pro": {
+		name: "DeepSeek V4 Pro",
+		contextWindow: 1_000_000,
+		maxTokens: 384_000,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 1.74, output: 3.48, cacheRead: 0.0145, cacheWrite: 0 },
+	},
+	"glm-5": {
+		name: "GLM-5",
+		contextWindow: 204_800,
+		maxTokens: 131_072,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 1, output: 3.2, cacheRead: 0.2, cacheWrite: 0 },
+	},
+	"glm-5.1": {
+		name: "GLM-5.1",
+		contextWindow: 200_000,
+		maxTokens: 131_072,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 },
+	},
+	"glm-5.2": {
+		name: "GLM-5.2",
+		contextWindow: 1_000_000,
+		maxTokens: 131_072,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 },
+	},
+	"kimi-k2.5": {
+		name: "Kimi K2.5",
+		contextWindow: 262_144,
+		maxTokens: 262_144,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 0.3, output: 1.9, cacheRead: 0, cacheWrite: 0 },
+	},
+	"kimi-k2.6": {
+		name: "Kimi K2.6",
+		contextWindow: 262_144,
+		maxTokens: 262_144,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 0.95, output: 4, cacheRead: 0.2, cacheWrite: 0 },
+	},
+	"kimi-k2.7-code": {
+		name: "Kimi K2.7 Code",
+		contextWindow: 262_144,
+		maxTokens: 262_144,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 0.95, output: 4, cacheRead: 0.19, cacheWrite: 0 },
+	},
+	"minimax-m2.5": {
+		name: "MiniMax M2.5",
+		contextWindow: 204_800,
+		maxTokens: 131_072,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0.375 },
+	},
+	"minimax-m2.7": {
+		name: "MiniMax M2.7",
+		contextWindow: 204_800,
+		maxTokens: 131_072,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0.375 },
+	},
+	"minimax-m3": {
+		name: "MiniMax M3",
+		contextWindow: 512_000,
+		maxTokens: 128_000,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 },
+	},
+	"qwen3.5-plus": {
+		name: "Qwen3.5 Plus",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 0.4, output: 2.4, cacheRead: 0, cacheWrite: 0 },
+	},
+	"qwen3.6-plus": {
+		name: "Qwen3.6 Plus",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 2, output: 6, cacheRead: 0.2, cacheWrite: 2.5 },
+	},
+	"qwen3.7-max": {
+		name: "Qwen3.7 Max",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 2.5, output: 7.5, cacheRead: 0.5, cacheWrite: 3.125 },
+	},
+	"qwen3.7-plus": {
+		name: "Qwen3.7 Plus",
+		contextWindow: 1_000_000,
+		maxTokens: 64_000,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 1.2, output: 4.8, cacheRead: 0.12, cacheWrite: 1.5 },
+	},
+	"mimo-v2-omni": {
+		name: "MiMo-V2-Omni",
+		contextWindow: 262_144,
+		maxTokens: 131_072,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 0.4, output: 2, cacheRead: 0.08, cacheWrite: 0 },
+	},
+	"mimo-v2-pro": {
+		name: "MiMo-V2-Pro",
+		contextWindow: 1_048_576,
+		maxTokens: 131_072,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 1, output: 3, cacheRead: 0.2, cacheWrite: 0 },
+	},
+	"mimo-v2.5": {
+		name: "MiMo-V2.5",
+		contextWindow: 1_048_576,
+		maxTokens: 131_072,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 0.14, output: 0.28, cacheRead: 0.0028, cacheWrite: 0 },
+	},
+	"mimo-v2.5-pro": {
+		name: "MiMo-V2.5-Pro",
+		contextWindow: 1_048_576,
+		maxTokens: 131_072,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 1.74, output: 3.48, cacheRead: 0.0145, cacheWrite: 0 },
+	},
+	"hy3-preview": {
+		name: "Hy3 preview",
+		contextWindow: 256_000,
+		maxTokens: 64_000,
+		input: ["text"],
+		reasoning: true,
+		cost: { input: 0.066, output: 0.26, cacheRead: 0.029, cacheWrite: 0 },
+	},
+};
+
+function applyOpenCodeGoOfficialMetadata<TApi extends Api>(model: Model<TApi>): Model<TApi> {
+	const metadata = OPENCODE_GO_OFFICIAL_MODELS[model.id];
+	if (!metadata) return model;
+	return {
+		...model,
+		name: metadata.name,
+		reasoning: metadata.reasoning,
+		input: [...metadata.input],
+		cost: { ...metadata.cost },
+		contextWindow: metadata.contextWindow,
+		maxTokens: metadata.maxTokens,
+	};
+}
+
+function createOpenCodeGoOfficialModels(): Model<Api>[] {
+	return Object.entries(OPENCODE_GO_OFFICIAL_MODELS).map(([id, metadata]) => {
+		const resolved = resolveApiByRules(
+			id,
+			{},
+			OPENCODE_GO_API_RESOLUTION.rules,
+			OPENCODE_GO_API_RESOLUTION.defaultResolution,
+		);
+		return {
+			id,
+			name: metadata.name,
+			api: resolved.api,
+			provider: "opencode-go",
+			baseUrl: resolved.baseUrl,
+			reasoning: metadata.reasoning,
+			input: [...metadata.input],
+			cost: { ...metadata.cost },
+			contextWindow: metadata.contextWindow,
+			maxTokens: metadata.maxTokens,
+		};
+	});
+}
+
 const MODELS_DEV_PROVIDER_DESCRIPTORS_SPECIALIZED: readonly ModelsDevProviderDescriptor[] = [
 	// --- Cloudflare AI Gateway ---
 	anthropicMessagesDescriptor(
@@ -2299,6 +2586,8 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_SPECIALIZED: readonly ModelsDevProviderDes
 				OPENCODE_GO_API_RESOLUTION.rules,
 				OPENCODE_GO_API_RESOLUTION.defaultResolution,
 			),
+		transformModel: model => applyOpenCodeGoOfficialMetadata(model),
+		appendModels: createOpenCodeGoOfficialModels(),
 	}),
 	// --- GitHub Copilot ---
 	openAiCompletionsDescriptor("github-copilot", "github-copilot", COPILOT_BASE_URL, {

package/src/providers/amazon-bedrock.ts

@@ -33,7 +33,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream";
 import { appendRawHttpRequestDumpFor400, type RawHttpRequestDump, withHttpStatus } from "../utils/http-inspector";
 import { parseStreamingJson } from "../utils/json-parse";
 import { resolveRetryBudget } from "../utils/retry-budget";
-import { toolWireSchema } from "../utils/schema/wire";
+import { flattenToolRootCombinators, toolWireSchema } from "../utils/schema";
 import {
 	isForcedToolChoiceUnsupportedError,
 	markToolChoiceIncapability,
@@ -808,7 +808,7 @@ export function convertToolConfig(
 		toolSpec: {
 			name: tool.name,
 			description: tool.description || "",
-			inputSchema: { json: toolWireSchema(tool) },
+			inputSchema: { json: flattenToolRootCombinators(toolWireSchema(tool)) },
 		},
 	}));
 

package/src/providers/anthropic.ts

@@ -62,7 +62,13 @@ import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { isCopilotTransientModelError } from "../utils/retry";
 import { resolveRetryBudget } from "../utils/retry-budget";
-import { COMBINATOR_KEYS, NO_STRICT, toolWireSchema } from "../utils/schema";
+import {
+	COMBINATOR_KEYS,
+	flattenToolRootCombinators,
+	isJsonSchemaObjectNode,
+	NO_STRICT,
+	toolWireSchema,
+} from "../utils/schema";
 import { spillToDescription } from "../utils/schema/spill";
 import { notifyRawSseEvent, wrapFetchForSseDebug } from "../utils/sse-debug";
 import {
@@ -2406,22 +2412,6 @@ const MAX_ANTHROPIC_STRICT_TOOLS = 20;
 const MAX_ANTHROPIC_STRICT_OPTIONAL_PARAMETERS = 24;
 const MAX_ANTHROPIC_STRICT_UNION_PARAMETERS = 16;
 
-/** `minItems` / `maxItems` apply to arrays; Anthropic rejects them on `type: "object"` (including `minItems: 0`/`1`). */
-function isJsonSchemaArrayNode(schema: Record<string, unknown>): boolean {
-	const t = schema.type;
-	if (t === "array") return true;
-	if (Array.isArray(t) && t.includes("array") && !t.includes("object")) return true;
-	return false;
-}
-
-function isJsonSchemaObjectNode(schema: Record<string, unknown>): boolean {
-	if (isJsonSchemaArrayNode(schema)) return false;
-	if (schema.type === "object") return true;
-	if (Array.isArray(schema.type) && schema.type.includes("object")) return true;
-	if (isRecord(schema.properties)) return true;
-	return false;
-}
-
 /**
  * Pick the principal non-null scalar type from a `type` keyword. Anthropic accepts
  * `type` as either a single string or an array (e.g. `["number", "null"]` for a
@@ -2573,111 +2563,6 @@ export function normalizeAnthropicToolSchema(schema: unknown): unknown {
 	return result;
 }
 
-function getRequiredNames(schema: Record<string, unknown>): Set<string> {
-	return new Set(
-		Array.isArray(schema.required)
-			? schema.required.filter((entry): entry is string => typeof entry === "string")
-			: [],
-	);
-}
-
-function getSingleLiteralValue(schema: unknown): unknown | undefined {
-	if (!isRecord(schema)) return undefined;
-	if (Object.hasOwn(schema, "const")) return schema.const;
-	if (Array.isArray(schema.enum) && schema.enum.length === 1) return schema.enum[0];
-	return undefined;
-}
-
-function describeAnthropicRootBranch(index: number, branch: Record<string, unknown>, action: unknown): string {
-	const required = [...getRequiredNames(branch)];
-	const parts = [`Branch ${index + 1}`];
-	if (typeof action === "string" || typeof action === "number" || typeof action === "boolean") {
-		parts.push(`action ${JSON.stringify(action)}`);
-	}
-	if (required.length > 0) parts.push(`branch-required fields: ${required.join(", ")}`);
-	if (typeof branch.description === "string" && branch.description.length > 0) parts.push(branch.description);
-	return parts.join("; ");
-}
-function collectAnthropicRootObjectBranches(schema: unknown): Record<string, unknown>[] | undefined {
-	if (!isRecord(schema)) return undefined;
-	if (isJsonSchemaObjectNode(schema)) return [schema];
-
-	const combinatorKeys = COMBINATOR_KEYS.filter(key => Array.isArray(schema[key]));
-	if (combinatorKeys.length === 0) return undefined;
-
-	const branches: Record<string, unknown>[] = [];
-	for (const key of combinatorKeys) {
-		const variants = schema[key];
-		if (!Array.isArray(variants) || variants.length === 0) return undefined;
-		for (const variant of variants) {
-			const nestedBranches = collectAnthropicRootObjectBranches(variant);
-			if (nestedBranches === undefined) return undefined;
-			branches.push(...nestedBranches);
-		}
-	}
-	return branches;
-}
-
-/**
- * Anthropic rejects tool `input_schema` roots containing top-level oneOf/anyOf/allOf.
- * Keep the generic normalizer schema-preserving, then flatten only provider-emitted
- * tool roots into one object while leaving nested combinators untouched.
- */
-export function normalizeAnthropicToolRootInputSchema(schema: Record<string, unknown>): Record<string, unknown> {
-	const result: Record<string, unknown> = { ...schema };
-	const rootCombinators = COMBINATOR_KEYS.filter(key => Array.isArray(result[key]));
-	if (rootCombinators.length === 0) return result;
-
-	const baseProperties = isRecord(result.properties) ? { ...result.properties } : {};
-	const flattenedBranches = rootCombinators
-		.map(key => ({ key, branches: collectAnthropicRootObjectBranches({ [key]: result[key] }) }))
-		.find(entry => entry.branches !== undefined && entry.branches.length > 0);
-
-	result.type = "object";
-	result.properties = baseProperties;
-	result.additionalProperties = result.additionalProperties === undefined ? false : result.additionalProperties;
-
-	if (flattenedBranches?.branches !== undefined) {
-		const variants = flattenedBranches.branches;
-		const commonRequired = variants.map(variant => getRequiredNames(variant));
-		const required = [...commonRequired[0]].filter(name => commonRequired.every(set => set.has(name)));
-		const actionValues: unknown[] = [];
-		const guidance: string[] = [];
-
-		for (const [index, branch] of variants.entries()) {
-			if (isRecord(branch.properties)) {
-				Object.assign(baseProperties, branch.properties);
-				const actionValue = getSingleLiteralValue(branch.properties.action);
-				if (actionValue !== undefined && !actionValues.includes(actionValue)) actionValues.push(actionValue);
-				guidance.push(describeAnthropicRootBranch(index, branch, actionValue));
-			} else {
-				guidance.push(describeAnthropicRootBranch(index, branch, undefined));
-			}
-		}
-
-		if (actionValues.length > 0) {
-			const existingAction = isRecord(baseProperties.action) ? { ...baseProperties.action } : {};
-			delete existingAction.const;
-			baseProperties.action = { ...existingAction, enum: actionValues };
-		}
-		result.required = required;
-		spillToDescription(result, [
-			["rootCombinatorGuidance", guidance],
-			...rootCombinators
-				.filter(key => key !== flattenedBranches.key)
-				.map(key => [key, result[key]] as [string, unknown]),
-		]);
-	} else {
-		spillToDescription(
-			result,
-			rootCombinators.map(key => [key, result[key]]),
-		);
-	}
-
-	for (const key of COMBINATOR_KEYS) delete result[key];
-	return result;
-}
-
 type AnthropicToolInputSchema = Anthropic.Messages.Tool["input_schema"];
 
 type AnthropicToolSchemaPlan = {
@@ -2845,7 +2730,7 @@ function normalizeAnthropicStrictSchema(
 
 function buildAnthropicBaseToolInputSchema(tool: Tool): Record<string, unknown> {
 	const jsonSchema = toolWireSchema(tool);
-	return normalizeAnthropicToolRootInputSchema(
+	return flattenToolRootCombinators(
 		normalizeAnthropicToolSchema({
 			...jsonSchema,
 			type: "object",