@f5-sales-demo/pi-ai 21.49.4 → 22.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/pi-ai",
-	"version": "21.49.4",
+	"version": "22.0.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -46,7 +46,7 @@
 		"@anthropic-ai/sdk": "0.123.0",
 		"@aws-sdk/client-bedrock-runtime": "3.1126.0",
 		"@bufbuild/protobuf": "2.14.1",
-		"@f5-sales-demo/pi-utils": "21.49.4",
+		"@f5-sales-demo/pi-utils": "22.0.0",
 		"@google/genai": "2.21.0",
 		"@sinclair/typebox": "0.34.52",
 		"@smithy/node-http-handler": "4.12.1",

package/src/codex-model-interaction.ts

@@ -0,0 +1,164 @@
+import type { ReasoningEffort } from "./model-thinking";
+import type { Api, Model, ServiceTier, ThinkingConfig } from "./types";
+
+export type CodexContextTier = "standard" | "codex-max" | "provider-max";
+export type ReasoningSummary = "none" | "auto" | "concise" | "detailed";
+export type WireReasoningSummary = Exclude<ReasoningSummary, "none">;
+
+export interface CodexModelInteractionMetadata {
+	standardContextWindow: number;
+	maxContextWindow: number;
+	internalProviderMaxContextWindow: number;
+	outputLimit: number;
+	effectiveContextWindowPercent: number;
+	autoCompactThresholdPercent: number;
+	defaultReasoningSummary: ReasoningSummary;
+	defaultVerbosity: "low" | "medium" | "high";
+	thinking: ThinkingConfig;
+	serviceTiers: ServiceTier[];
+	defaultServiceTier: ServiceTier;
+	truncationPolicy: { mode: "tokens" | "bytes"; limit: number };
+	supportsParallelToolCalls: boolean;
+	ultraReasoningEffort?: ReasoningEffort;
+}
+
+const descriptions: Record<ReasoningEffort, string> = {
+	none: "No reasoning",
+	minimal: "Minimal reasoning",
+	low: "Light reasoning",
+	medium: "Balanced reasoning",
+	high: "Deep reasoning",
+	xhigh: "Very deep reasoning",
+	max: "Maximum reasoning",
+	ultra: "Maximum reasoning with automatic task delegation",
+};
+
+function metadata(
+	defaultLevel: ReasoningEffort,
+	supported: ReasoningEffort[],
+	defaultServiceTier: ServiceTier,
+	maxContextWindow = 872_000,
+	internalProviderMaxContextWindow = 1_050_000,
+	ultraReasoningEffort: ReasoningEffort = "max",
+): CodexModelInteractionMetadata {
+	return {
+		standardContextWindow: 272_000,
+		maxContextWindow,
+		internalProviderMaxContextWindow,
+		outputLimit: 128_000,
+		effectiveContextWindowPercent: 95,
+		autoCompactThresholdPercent: 90,
+		defaultReasoningSummary: "none",
+		defaultVerbosity: "low",
+		thinking: {
+			mode: "effort",
+			defaultLevel,
+			supportedLevels: supported.map(effort => ({ effort, description: descriptions[effort] })),
+		},
+		serviceTiers: ["default", "priority"],
+		defaultServiceTier,
+		truncationPolicy: { mode: "tokens", limit: 10_000 },
+		supportsParallelToolCalls: true,
+		...(supported.includes("ultra") ? { ultraReasoningEffort } : {}),
+	};
+}
+
+export const CODEX_MODEL_INTERACTION_METADATA: Readonly<Record<string, CodexModelInteractionMetadata>> = {
+	"gpt-6-astra": metadata(
+		"low",
+		["low", "medium", "high", "xhigh", "max", "ultra"],
+		"default",
+		872_000,
+		922_000,
+		"xhigh",
+	),
+	"gpt-6-sol": metadata("medium", ["low", "medium", "high", "xhigh", "max", "ultra"], "priority", 872_000, 922_000),
+	"gpt-6-luna": metadata("medium", ["low", "medium", "high", "xhigh", "max"], "priority", 872_000, 922_000),
+	"gpt-5.6-sol": metadata("low", ["low", "medium", "high", "xhigh", "max", "ultra"], "default"),
+	"gpt-5.6-terra": metadata("medium", ["low", "medium", "high", "xhigh", "max", "ultra"], "default"),
+	"gpt-5.6-luna": metadata("medium", ["low", "medium", "high", "xhigh", "max"], "default"),
+	"gpt-5.5": metadata("medium", ["low", "medium", "high", "xhigh"], "default", 272_000),
+};
+
+export function resolveCodexContextBudget(
+	modelId: string,
+	tier: CodexContextTier,
+	providerContextWindow?: number,
+): { contextWindow: number; effectiveContextWindow: number; autoCompactTokenLimit: number } | undefined {
+	const interaction = CODEX_MODEL_INTERACTION_METADATA[modelId];
+	if (!interaction) return undefined;
+	const providerLimit =
+		typeof providerContextWindow === "number" && Number.isFinite(providerContextWindow) && providerContextWindow > 0
+			? Math.floor(providerContextWindow)
+			: interaction.maxContextWindow;
+	let contextWindow: number;
+	if (tier === "standard") {
+		contextWindow = Math.min(interaction.standardContextWindow, providerLimit);
+	} else if (tier === "codex-max") {
+		contextWindow = Math.min(interaction.maxContextWindow, providerLimit);
+	} else {
+		contextWindow = providerLimit;
+	}
+	return {
+		contextWindow,
+		effectiveContextWindow: Math.floor((contextWindow * interaction.effectiveContextWindowPercent) / 100),
+		autoCompactTokenLimit: Math.floor((contextWindow * interaction.autoCompactThresholdPercent) / 100),
+	};
+}
+
+export function resolveCodexWireReasoningEffort(modelId: string, effort: ReasoningEffort): ReasoningEffort {
+	if (effort !== "ultra") return effort;
+	return CODEX_MODEL_INTERACTION_METADATA[modelId]?.ultraReasoningEffort ?? "max";
+}
+
+export function resolveWireReasoningSummary(summary: ReasoningSummary): WireReasoningSummary | undefined {
+	return summary === "none" ? undefined : summary;
+}
+
+/** Return the model's usable runtime context, clamped to its selected provider-facing window. */
+export function getModelEffectiveContextWindow(model: Pick<Model, "contextWindow" | "effectiveContextWindow">): number {
+	const contextWindow =
+		typeof model.contextWindow === "number" && Number.isFinite(model.contextWindow) && model.contextWindow > 0
+			? Math.floor(model.contextWindow)
+			: 0;
+	const effectiveContextWindow =
+		typeof model.effectiveContextWindow === "number" &&
+		Number.isFinite(model.effectiveContextWindow) &&
+		model.effectiveContextWindow > 0
+			? Math.floor(model.effectiveContextWindow)
+			: contextWindow;
+	return contextWindow > 0 ? Math.min(contextWindow, effectiveContextWindow) : effectiveContextWindow;
+}
+
+export function applyCodexInteractionMetadata<TApi extends Api>(
+	model: Model<TApi>,
+	providerContextWindow?: number,
+): Model<TApi> {
+	if (model.provider !== "openai-codex" && model.provider !== "litellm") return model;
+	const interaction = CODEX_MODEL_INTERACTION_METADATA[model.id];
+	if (!interaction) return model;
+	const rawProviderLimit =
+		providerContextWindow ??
+		model.providerContextWindow ??
+		(model.provider === "openai-codex" ? interaction.maxContextWindow : model.contextWindow);
+	const advertisedLimit = Math.min(rawProviderLimit, interaction.internalProviderMaxContextWindow);
+	const budget = resolveCodexContextBudget(model.id, "standard", advertisedLimit)!;
+	return {
+		...model,
+		thinking: interaction.thinking,
+		contextWindow: budget.contextWindow,
+		maxContextWindow: interaction.maxContextWindow,
+		maxTokens: interaction.outputLimit,
+		providerContextWindow: advertisedLimit,
+		effectiveContextWindowPercent: interaction.effectiveContextWindowPercent,
+		autoCompactThresholdPercent: interaction.autoCompactThresholdPercent,
+		effectiveContextWindow: budget.effectiveContextWindow,
+		autoCompactTokenLimit: budget.autoCompactTokenLimit,
+		defaultReasoningSummary: interaction.defaultReasoningSummary,
+		defaultVerbosity: interaction.defaultVerbosity,
+		serviceTiers: interaction.serviceTiers,
+		defaultServiceTier: interaction.defaultServiceTier,
+		truncationPolicy: interaction.truncationPolicy,
+		supportsParallelToolCalls: interaction.supportsParallelToolCalls,
+	};
+}

package/src/index.ts

@@ -2,6 +2,7 @@ export type { Static, TSchema } from "@sinclair/typebox";
 export { Type } from "@sinclair/typebox";
 export * from "./api-registry";
 export * from "./auth-storage";
+export * from "./codex-model-interaction";
 export * from "./model-cache";
 export * from "./model-manager";
 export * from "./model-thinking";

package/src/model-thinking.ts

@@ -15,6 +15,7 @@ export const enum Effort {
 	High = "high",
 	XHigh = "xhigh",
 	Max = "max",
+	Ultra = "ultra",
 }
 
 /** Public reasoning preset enum. `none` is distinct from inheriting the provider default. */
@@ -26,8 +27,9 @@ export const ReasoningEffort = {
 	High: Effort.High,
 	XHigh: Effort.XHigh,
 	Max: Effort.Max,
+	Ultra: Effort.Ultra,
 } as const;
-export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | "ultra";
 
 /**
  * Anthropic's `output_config.effort` enum, verbatim. Authority is the API's own
@@ -47,7 +49,7 @@ export type EffortThroughXHigh = "minimal" | "low" | "medium" | "high" | "xhigh"
  * clamping is the safe direction if a caller bypasses the range check.
  */
 export function clampEffortThroughXHigh(effort: Effort): EffortThroughXHigh {
-	return effort === Effort.Max ? Effort.XHigh : effort;
+	return effort === Effort.Max || effort === Effort.Ultra ? Effort.XHigh : effort;
 }
 
 /** Order is load-bearing: `indexOf` drives expandEffortRange/requireSupportedEffort. */
@@ -58,6 +60,7 @@ export const THINKING_EFFORTS: readonly Effort[] = [
 	Effort.High,
 	Effort.XHigh,
 	Effort.Max,
+	Effort.Ultra,
 ];
 
 export const REASONING_EFFORTS: readonly ReasoningEffort[] = [ReasoningEffort.None, ...THINKING_EFFORTS];
@@ -70,6 +73,7 @@ const EFFORT_DESCRIPTIONS: Readonly<Record<ReasoningEffort, string>> = {
 	[ReasoningEffort.High]: "Deep reasoning",
 	[ReasoningEffort.XHigh]: "Very deep reasoning",
 	[ReasoningEffort.Max]: "Maximum reasoning",
+	[ReasoningEffort.Ultra]: "Maximum reasoning with automatic task delegation",
 };
 
 /** Build explicit metadata for custom models and programmatic registries. */
@@ -365,6 +369,7 @@ export function mapEffortToGoogleThinkingLevel<TApi extends Api>(
 		case Effort.High:
 		case Effort.XHigh:
 		case Effort.Max:
+		case Effort.Ultra:
 			return "HIGH";
 	}
 }
@@ -391,6 +396,7 @@ export function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(
 		case Effort.XHigh:
 			return "xhigh";
 		case Effort.Max:
+		case Effort.Ultra:
 			return "max";
 	}
 }

package/src/models.ts

@@ -1,3 +1,4 @@
+import { applyCodexInteractionMetadata } from "./codex-model-interaction";
 import { enrichModelThinking } from "./model-thinking";
 import MODELS from "./models.json" with { type: "json" };
 import type { Api, KnownProvider, Model, Usage } from "./types";
@@ -14,7 +15,7 @@ const modelRegistry: Map<string, Map<string, Model<Api>>> = new Map();
 for (const [provider, models] of Object.entries(MODELS)) {
 	const providerModels = new Map<string, Model<Api>>();
 	for (const [id, model] of Object.entries(models)) {
-		providerModels.set(id, enrichModelThinking(model as Model<Api>));
+		providerModels.set(id, applyCodexInteractionMetadata(enrichModelThinking(model as Model<Api>)));
 	}
 	modelRegistry.set(provider, providerModels);
 }

package/src/provider-models/special.ts

@@ -18,6 +18,7 @@ export function openaiCodexModelManagerOptions(
 	const { accessToken, accountId, clientVersion } = config;
 	return {
 		providerId: "openai-codex",
+		staticModels: [],
 		...(accessToken
 			? {
 					fetchDynamicModels: async () => {

package/src/providers/amazon-bedrock.ts

@@ -660,6 +660,7 @@ function buildAdditionalModelRequestFields(
 		high: 16384,
 		xhigh: 32768,
 		max: 65536,
+		ultra: 65536,
 	};
 	const budget = options.thinkingBudgets?.[level] ?? defaultBudgets[level];
 

package/src/providers/cursor.ts

@@ -11,8 +11,8 @@ import type {
 	Context,
 	CursorExecHandlerResult,
 	CursorExecHandlers,
-	CursorMcpCall,
 	CursorShellStreamCallbacks,
+	CursorToolCall,
 	CursorToolResultHandler,
 	ImageContent,
 	Message,
@@ -225,7 +225,7 @@ function extractLogBytes(value: unknown): Uint8Array | null {
 	return null;
 }
 
-function decodeMcpArgsForLog(args?: Record<string, unknown>): Record<string, unknown> | undefined {
+function decodeToolArgsForLog(args?: Record<string, unknown>): Record<string, unknown> | undefined {
 	if (!args) {
 		return undefined;
 	}
@@ -234,7 +234,7 @@ function decodeMcpArgsForLog(args?: Record<string, unknown>): Record<string, unk
 	for (const [key, value] of Object.entries(args)) {
 		const bytes = extractLogBytes(value);
 		if (bytes) {
-			decoded[key] = decodeMcpArgValue(bytes);
+			decoded[key] = decodeToolArgValue(bytes);
 			mutated = true;
 			continue;
 		}
@@ -259,13 +259,13 @@ function decodeLogData(value: unknown): unknown {
 	const stripTypeName = typeof typeName === "string" && typeName.startsWith("agent.v1.");
 
 	if (typeName === "agent.v1.McpArgs") {
-		const decodedArgs = decodeMcpArgsForLog(record.args as Record<string, unknown> | undefined);
+		const decodedArgs = decodeToolArgsForLog(record.args as Record<string, unknown> | undefined);
 		const base = stripTypeName ? omitTypeName(record) : record;
 		return decodedArgs ? { ...base, args: decodedArgs } : base;
 	}
 	if (typeName === "agent.v1.McpToolCall") {
 		const argsRecord = record.args as Record<string, unknown> | undefined;
-		const decodedArgs = decodeMcpArgsForLog(argsRecord?.args as Record<string, unknown> | undefined);
+		const decodedArgs = decodeToolArgsForLog(argsRecord?.args as Record<string, unknown> | undefined);
 		const base = stripTypeName ? omitTypeName(record) : record;
 		if (decodedArgs && argsRecord) {
 			return { ...base, args: { ...argsRecord, args: decodedArgs } };
@@ -363,7 +363,7 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 				conversationState: cachedState,
 			});
 			conversationStateCache.set(conversationId, conversationState);
-			const requestContextTools = buildMcpToolDefinitions(context.tools);
+			const requestContextTools = buildCursorToolDefinitions(context.tools);
 
 			const baseUrl = model.baseUrl || CURSOR_API_URL;
 			h2Client = http2.connect(baseUrl);
@@ -569,7 +569,7 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 	return stream;
 };
 
-type ToolCallState = ToolCall & { index: number; partialJson?: string; kind: "mcp" | "todo_write" };
+type ToolCallState = ToolCall & { index: number; partialJson?: string; kind: "tool" | "todo_write" };
 
 interface BlockState {
 	currentTextBlock: (TextContent & { index: number }) | null;
@@ -1042,14 +1042,14 @@ async function handleExecServerMessage(
 		}
 		case "mcpArgs": {
 			const args = execMsg.message.value;
-			const mcpCall = decodeMcpCall(args);
+			const toolCall = decodeCursorToolCall(args);
 			const { execResult } = await resolveExecHandler(
-				mcpCall,
-				execHandlers?.mcp?.bind(execHandlers),
+				toolCall,
+				execHandlers?.tool?.bind(execHandlers),
 				onToolResult,
-				toolResult => buildMcpResultFromToolResult(mcpCall, toolResult),
-				_reason => buildMcpToolNotFoundResult(mcpCall),
-				error => buildMcpErrorResult(error),
+				toolResult => buildCursorToolResult(toolResult),
+				_reason => buildCursorToolNotFoundResult(toolCall),
+				error => buildCursorToolErrorResult(error),
 			);
 			sendExecClientMessage(h2Request, execMsg, "mcpResult", execResult);
 			return;
@@ -1652,7 +1652,7 @@ function parseToolArgsJson(text: string): unknown {
 	return text;
 }
 
-function decodeMcpArgValue(value: Uint8Array): unknown {
+function decodeToolArgValue(value: Uint8Array): unknown {
 	try {
 		const parsedValue = fromBinary(ValueSchema, value);
 		const jsonValue = toJson(ValueSchema, parsedValue) as JsonValue;
@@ -1665,27 +1665,27 @@ function decodeMcpArgValue(value: Uint8Array): unknown {
 	return parseToolArgsJson(text);
 }
 
-function decodeMcpArgsMap(args?: Record<string, Uint8Array>): Record<string, unknown> | undefined {
+function decodeToolArgsMap(args?: Record<string, Uint8Array>): Record<string, unknown> | undefined {
 	if (!args) {
 		return undefined;
 	}
 	const decoded: Record<string, unknown> = {};
 	for (const [key, value] of Object.entries(args)) {
-		decoded[key] = decodeMcpArgValue(value);
+		decoded[key] = decodeToolArgValue(value);
 	}
 	return decoded;
 }
 
-function decodeMcpCall(args: {
+function decodeCursorToolCall(args: {
 	name: string;
 	args: Record<string, Uint8Array>;
 	toolCallId: string;
 	providerIdentifier: string;
 	toolName: string;
-}): CursorMcpCall {
+}): CursorToolCall {
 	const decodedArgs: Record<string, unknown> = {};
 	for (const [key, value] of Object.entries(args.args ?? {})) {
-		decodedArgs[key] = decodeMcpArgValue(value);
+		decodedArgs[key] = decodeToolArgValue(value);
 	}
 	return {
 		name: args.name,
@@ -1733,9 +1733,9 @@ function buildTodoWriteArgs(toolCall: CursorUpdateTodosToolCall): {
 	};
 }
 
-function buildMcpResultFromToolResult(_mcpCall: CursorMcpCall, toolResult: ToolResultMessage) {
+function buildCursorToolResult(toolResult: ToolResultMessage) {
 	if (toolResult.isError) {
-		return buildMcpErrorResult(toolResultToText(toolResult) || "MCP tool failed");
+		return buildCursorToolErrorResult(toolResultToText(toolResult) || "Tool failed");
 	}
 	const content = toolResult.content.map(item => {
 		if (item.type === "image") {
@@ -1768,16 +1768,16 @@ function buildMcpResultFromToolResult(_mcpCall: CursorMcpCall, toolResult: ToolR
 	});
 }
 
-function buildMcpToolNotFoundResult(mcpCall: CursorMcpCall) {
+function buildCursorToolNotFoundResult(toolCall: CursorToolCall) {
 	return create(McpResultSchema, {
 		result: {
 			case: "toolNotFound",
-			value: create(McpToolNotFoundSchema, { name: mcpCall.toolName, availableTools: [] }),
+			value: create(McpToolNotFoundSchema, { name: toolCall.toolName, availableTools: [] }),
 		},
 	});
 }
 
-function buildMcpErrorResult(error: string) {
+function buildCursorToolErrorResult(error: string) {
 	return create(McpResultSchema, {
 		result: {
 			case: "error",
@@ -1854,7 +1854,7 @@ function processInteractionUpdate(
 					arguments: {},
 					index: output.content.length,
 					partialJson: "",
-					kind: "mcp",
+					kind: "tool",
 				};
 				output.content.push(block);
 				state.setToolCall(block);
@@ -1879,7 +1879,7 @@ function processInteractionUpdate(
 			}
 		}
 	} else if (updateCase === "toolCallDelta" || updateCase === "partialToolCall") {
-		if (state.currentToolCall?.kind === "mcp") {
+		if (state.currentToolCall?.kind === "tool") {
 			const delta = update.message.value.argsTextDelta || "";
 			state.currentToolCall.partialJson = `${state.currentToolCall.partialJson ?? ""}${delta}`;
 			state.currentToolCall.arguments = parseStreamingJson(state.currentToolCall.partialJson ?? "");
@@ -1889,8 +1889,8 @@ function processInteractionUpdate(
 	} else if (updateCase === "toolCallCompleted") {
 		if (state.currentToolCall) {
 			const toolCall = update.message.value.toolCall;
-			if (state.currentToolCall.kind === "mcp") {
-				const decodedArgs = decodeMcpArgsMap(toolCall?.mcpToolCall?.args?.args);
+			if (state.currentToolCall.kind === "tool") {
+				const decodedArgs = decodeToolArgsMap(toolCall?.mcpToolCall?.args?.args);
 				if (decodedArgs) {
 					state.currentToolCall.arguments = decodedArgs;
 				}
@@ -1943,7 +1943,7 @@ function createBlobId(data: Uint8Array): Uint8Array {
 
 const CURSOR_NATIVE_TOOL_NAMES = new Set(["bash", "read", "write", "delete", "ls", "grep", "lsp", "todo_write"]);
 
-function buildMcpToolDefinitions(tools: Tool[] | undefined): McpToolDefinition[] {
+function buildCursorToolDefinitions(tools: Tool[] | undefined): McpToolDefinition[] {
 	if (!tools || tools.length === 0) {
 		return [];
 	}

package/src/providers/openai-codex/request-transformer.ts

@@ -1,17 +1,24 @@
+import {
+	type ReasoningSummary,
+	resolveCodexWireReasoningEffort,
+	resolveWireReasoningSummary,
+	type WireReasoningSummary,
+} from "../../codex-model-interaction";
 import type { ReasoningEffort } from "../../model-thinking";
 import { requireSupportedReasoningEffort } from "../../model-thinking";
 import type { Api, Model } from "../../types";
 
 export interface ReasoningConfig {
-	effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
-	summary: "auto" | "concise" | "detailed" | null;
+	effort: ReasoningEffort;
+	summary?: WireReasoningSummary;
 }
 
 export interface CodexRequestOptions {
 	reasoningEffort?: ReasoningConfig["effort"];
-	reasoningSummary?: ReasoningConfig["summary"] | null;
+	reasoningSummary?: ReasoningSummary | null;
 	textVerbosity?: "low" | "medium" | "high";
 	include?: string[];
+	metadata?: Record<string, unknown>;
 }
 
 export interface InputItem {
@@ -33,6 +40,7 @@ export interface RequestBody {
 	input?: InputItem[];
 	tools?: unknown;
 	tool_choice?: unknown;
+	parallel_tool_calls?: boolean;
 	temperature?: number;
 	top_p?: number;
 	top_k?: number;
@@ -46,18 +54,88 @@ export interface RequestBody {
 	include?: string[];
 	prompt_cache_key?: string;
 	prompt_cache_retention?: "in_memory" | "24h";
+	service_tier?: string;
+	client_metadata?: Record<string, string>;
 	max_output_tokens?: number;
 	max_completion_tokens?: number;
 	[key: string]: unknown;
 }
 
 function getReasoningConfig(model: Model<Api>, options: CodexRequestOptions): ReasoningConfig {
+	const summary = resolveWireReasoningSummary(options.reasoningSummary ?? model.defaultReasoningSummary ?? "none");
 	return {
-		effort: requireSupportedReasoningEffort(model, options.reasoningEffort as ReasoningEffort),
-		summary: options.reasoningSummary ?? "detailed",
+		effort: resolveCodexWireReasoningEffort(
+			model.id,
+			requireSupportedReasoningEffort(
+				model,
+				(options.reasoningEffort ?? model.thinking?.defaultLevel) as ReasoningEffort,
+			),
+		),
+		...(summary ? { summary } : {}),
 	};
 }
 
+export function normalizeClientMetadata(
+	metadata: Record<string, unknown> | undefined,
+): Record<string, string> | undefined {
+	if (!metadata) return undefined;
+	const entries = Object.entries(metadata).flatMap(([key, value]) => {
+		if (typeof value === "string") return [[key, value] as const];
+		if (typeof value === "number" || typeof value === "boolean") return [[key, String(value)] as const];
+		return [];
+	});
+	return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+function utf8Length(value: string): number {
+	return new TextEncoder().encode(value).byteLength;
+}
+
+function truncateMiddle(value: string, policy: NonNullable<Model<Api>["truncationPolicy"]>): string {
+	const maxBytes = policy.mode === "tokens" ? policy.limit * 4 : policy.limit;
+	const totalBytes = utf8Length(value);
+	if (value.length === 0 || (maxBytes > 0 && totalBytes <= maxBytes)) return value;
+
+	const characters = Array.from(value);
+	const leftBudget = Math.floor(Math.max(0, maxBytes) / 2);
+	const rightBudget = Math.max(0, maxBytes) - leftBudget;
+	let leftBytes = 0;
+	let leftCount = 0;
+	while (leftCount < characters.length) {
+		const nextBytes = utf8Length(characters[leftCount]!);
+		if (leftBytes + nextBytes > leftBudget) break;
+		leftBytes += nextBytes;
+		leftCount += 1;
+	}
+
+	let rightBytes = 0;
+	let rightStart = characters.length;
+	while (rightStart > leftCount) {
+		const nextBytes = utf8Length(characters[rightStart - 1]!);
+		if (rightBytes + nextBytes > rightBudget) break;
+		rightBytes += nextBytes;
+		rightStart -= 1;
+	}
+
+	const removed =
+		policy.mode === "tokens"
+			? Math.ceil(Math.max(0, totalBytes - Math.max(0, maxBytes)) / 4)
+			: Math.max(0, characters.length - leftCount - (characters.length - rightStart));
+	const unit = policy.mode === "tokens" ? "tokens" : "chars";
+	return `${characters.slice(0, leftCount).join("")}…${removed} ${unit} truncated…${characters.slice(rightStart).join("")}`;
+}
+
+export function truncateFunctionCallOutputs(
+	input: InputItem[] | undefined,
+	policy: Model<Api>["truncationPolicy"],
+): InputItem[] | undefined {
+	if (!input || !policy) return input;
+	return input.map(item => {
+		if (item.type !== "function_call_output" || typeof item.output !== "string") return item;
+		return { ...item, output: truncateMiddle(item.output, policy) };
+	});
+}
+
 function filterInput(input: InputItem[] | undefined): InputItem[] | undefined {
 	if (!Array.isArray(input)) return input;
 
@@ -80,6 +158,8 @@ export async function transformRequestBody(
 ): Promise<RequestBody> {
 	body.store = false;
 	body.stream = true;
+	body.tool_choice = "auto";
+	body.parallel_tool_calls = model.supportsParallelToolCalls ?? false;
 	// The ChatGPT Codex backend rejects sampling controls with `Unsupported parameter`.
 	// Generic stream options may supply defaults, so remove them at the provider boundary.
 	delete body.temperature;
@@ -90,7 +170,7 @@ export async function transformRequestBody(
 	delete body.repetition_penalty;
 
 	if (body.input && Array.isArray(body.input)) {
-		body.input = filterInput(body.input);
+		body.input = truncateFunctionCallOutputs(filterInput(body.input), model.truncationPolicy);
 
 		if (body.input) {
 			const functionCallIds = new Set(
@@ -139,10 +219,11 @@ export async function transformRequestBody(
 		body.input = [...developerMessages, ...body.input];
 	}
 
-	if (options.reasoningEffort !== undefined) {
+	if (model.reasoning && (model.thinking || options.reasoningEffort !== undefined)) {
 		const reasoningConfig = getReasoningConfig(model, options);
+		const { summary: _summary, ...existingReasoning } = body.reasoning ?? {};
 		body.reasoning = {
-			...body.reasoning,
+			...existingReasoning,
 			...reasoningConfig,
 		};
 	} else {
@@ -151,9 +232,20 @@ export async function transformRequestBody(
 
 	body.text = {
 		...body.text,
-		verbosity: options.textVerbosity || "medium",
+		verbosity: options.textVerbosity ?? model.defaultVerbosity ?? "low",
 	};
 
+	const requestedServiceTier = body.service_tier ?? model.defaultServiceTier;
+	if (requestedServiceTier) {
+		if (model.serviceTiers && !model.serviceTiers.includes(requestedServiceTier as never)) {
+			throw new Error(
+				`Service tier "${requestedServiceTier}" is unavailable for ${model.provider}/${model.id}. Supported tiers: ${model.serviceTiers.join(", ")}`,
+			);
+		}
+		body.service_tier = requestedServiceTier;
+	}
+	body.client_metadata = normalizeClientMetadata(options.metadata);
+
 	const include = Array.isArray(options.include) ? [...options.include] : [];
 	include.push("reasoning.encrypted_content");
 	body.include = Array.from(new Set(include));

package/src/providers/openai-codex-responses.ts

@@ -19,6 +19,7 @@ import type {
 	ResponseReasoningItem,
 } from "openai/resources/responses/responses";
 import packageJson from "../../package.json" with { type: "json" };
+import type { ReasoningEffort } from "../model-thinking";
 import { calculateCost } from "../models";
 import { isUsageLimitError } from "../rate-limit-utils";
 import { getEnvApiKey } from "../stream";
@@ -72,8 +73,8 @@ import {
 import { transformMessages } from "./transform-messages";
 
 export interface OpenAICodexResponsesOptions extends StreamOptions {
-	reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
-	reasoningSummary?: "auto" | "concise" | "detailed" | null;
+	reasoning?: ReasoningEffort;
+	reasoningSummary?: "none" | "auto" | "concise" | "detailed" | null;
 	textVerbosity?: "low" | "medium" | "high";
 	include?: string[];
 	codexMode?: boolean;
@@ -527,9 +528,10 @@ async function buildTransformedCodexRequestBody(
 
 	const codexOptions: CodexRequestOptions = {
 		reasoningEffort: options?.reasoning,
-		reasoningSummary: options?.reasoningSummary ?? "auto",
+		reasoningSummary: options?.reasoningSummary,
 		textVerbosity: options?.textVerbosity,
 		include: options?.include,
+		metadata: options?.metadata,
 	};
 
 	return transformRequestBody(params, model, codexOptions, systemPrompt);

package/src/providers/openai-responses.ts

@@ -5,6 +5,14 @@ import type {
 	ResponseCreateParamsStreaming,
 	ResponseInput,
 } from "openai/resources/responses/responses";
+import {
+	type ReasoningSummary,
+	resolveCodexWireReasoningEffort,
+	resolveWireReasoningSummary,
+	type WireReasoningSummary,
+} from "../codex-model-interaction";
+import type { ReasoningEffort } from "../model-thinking";
+import { requireSupportedReasoningEffort } from "../model-thinking";
 import { getEnvApiKey } from "../stream";
 import {
 	type Api,
@@ -47,6 +55,7 @@ import {
 	hasCopilotVisionInput,
 	resolveGitHubCopilotBaseUrl,
 } from "./github-copilot-headers";
+import { normalizeClientMetadata, truncateFunctionCallOutputs } from "./openai-codex/request-transformer";
 import {
 	appendResponsesToolResultMessages,
 	collectKnownCallIds,
@@ -73,8 +82,9 @@ function getPromptCacheRetention(baseUrl: string, cacheRetention: CacheRetention
 
 // OpenAI Responses-specific options
 export interface OpenAIResponsesOptions extends StreamOptions {
-	reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
-	reasoningSummary?: "auto" | "detailed" | "concise" | null;
+	reasoning?: ReasoningEffort;
+	reasoningSummary?: ReasoningSummary | null;
+	textVerbosity?: "low" | "medium" | "high";
 	serviceTier?: ServiceTier;
 	toolChoice?: ToolChoice;
 	/**
@@ -125,12 +135,17 @@ function canReplayOpenAIResponsesNativeHistory(
 	return providerSessionState?.nativeHistoryReplayWarmed ?? true;
 }
 
-type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
+type OpenAIResponsesSamplingParams = Omit<ResponseCreateParamsStreaming, "reasoning"> & {
+	reasoning?: {
+		effort?: Exclude<ReasoningEffort, "ultra">;
+		summary?: WireReasoningSummary;
+	};
 	top_p?: number;
 	top_k?: number;
 	min_p?: number;
 	presence_penalty?: number;
 	repetition_penalty?: number;
+	client_metadata?: Record<string, string>;
 };
 
 /**
@@ -193,7 +208,10 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				url: `${baseUrl ?? "https://api.openai.com/v1"}/responses`,
 				body: params,
 			};
-			const openaiStream = await client.responses.create(params, { signal: requestSignal });
+			// The pinned SDK schema predates the provider's `max` effort value.
+			const openaiStream = await client.responses.create(params as ResponseCreateParamsStreaming, {
+				signal: requestSignal,
+			});
 			const firstEventWatchdog = createFirstEventWatchdog(
 				options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs),
 				() => abortTracker.abortLocally(firstEventTimeoutAbortError),
@@ -325,7 +343,7 @@ function buildParams(
 		strictResponsesPairing,
 		providerSessionState,
 	);
-	const messages: ResponseInput = [...conversationMessages];
+	let messages: ResponseInput = [...conversationMessages];
 
 	if (context.systemPrompt) {
 		const role = model.reasoning && supportsDeveloperRole(resolvedBaseUrl ?? model) ? "developer" : "system";
@@ -337,6 +355,7 @@ function buildParams(
 
 	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 	const promptCacheKey = cacheRetention === "none" ? undefined : options?.sessionId;
+	const hasCodexInteractionDefaults = model.defaultReasoningSummary !== undefined;
 	const params: OpenAIResponsesSamplingParams = {
 		model: model.id,
 		input: messages,
@@ -346,6 +365,14 @@ function buildParams(
 		store: false,
 	};
 
+	if (model.truncationPolicy) {
+		messages = truncateFunctionCallOutputs(
+			messages as unknown as import("./openai-codex/request-transformer").InputItem[],
+			model.truncationPolicy,
+		) as unknown as ResponseInput;
+		params.input = messages;
+	}
+
 	if (options?.maxTokens) {
 		params.max_output_tokens = options?.maxTokens;
 	}
@@ -369,16 +396,28 @@ function buildParams(
 	if (options?.repetitionPenalty !== undefined) {
 		params.repetition_penalty = options.repetitionPenalty;
 	}
-	if (isSpecialServiceTier(options?.serviceTier)) {
-		params.service_tier = options.serviceTier;
+	const requestedServiceTier = options?.serviceTier ?? model.defaultServiceTier;
+	if (requestedServiceTier && model.serviceTiers) {
+		if (!model.serviceTiers.includes(requestedServiceTier)) {
+			throw new Error(
+				`Service tier "${requestedServiceTier}" is unavailable for ${model.provider}/${model.id}. Supported tiers: ${model.serviceTiers.join(", ")}`,
+			);
+		}
+		params.service_tier = requestedServiceTier;
+	} else if (isSpecialServiceTier(requestedServiceTier)) {
+		params.service_tier = requestedServiceTier;
 	}
 
 	if (context.tools) {
 		params.tools = convertTools(context.tools, supportsStrictMode(model));
-		if (options?.toolChoice) {
+		if (!hasCodexInteractionDefaults && options?.toolChoice) {
 			params.tool_choice = mapToOpenAIResponsesToolChoice(options.toolChoice);
 		}
 	}
+	if (hasCodexInteractionDefaults) params.tool_choice = "auto";
+	if (model.supportsParallelToolCalls !== undefined) {
+		params.parallel_tool_calls = model.supportsParallelToolCalls;
+	}
 
 	if (model.reasoning) {
 		// Always request encrypted reasoning content so reasoning items can be
@@ -387,10 +426,19 @@ function buildParams(
 		// See: https://github.com/f5-sales-demo/xcsh/issues/41
 		params.include = ["reasoning.encrypted_content"];
 
-		if (options?.reasoning || options?.reasoningSummary) {
+		if (options?.reasoning || options?.reasoningSummary || hasCodexInteractionDefaults) {
+			const requestedEffort = (options?.reasoning ??
+				(hasCodexInteractionDefaults ? model.thinking?.defaultLevel : undefined) ??
+				"medium") as ReasoningEffort;
+			const supportedEffort = model.thinking
+				? requireSupportedReasoningEffort(model, requestedEffort)
+				: requestedEffort;
+			const summary = resolveWireReasoningSummary(
+				options?.reasoningSummary ?? model.defaultReasoningSummary ?? "auto",
+			);
 			params.reasoning = {
-				effort: options?.reasoning || "medium",
-				summary: options?.reasoningSummary || "auto",
+				effort: resolveCodexWireReasoningEffort(model.id, supportedEffort) as Exclude<ReasoningEffort, "ultra">,
+				...(summary ? { summary } : {}),
 			};
 		} else if (model.name.startsWith("gpt-5")) {
 			// Jesus Christ, see https://community.openai.com/t/need-reasoning-false-option-for-gpt-5/1351588/7
@@ -406,6 +454,13 @@ function buildParams(
 		}
 	}
 
+	if (options?.textVerbosity || model.defaultVerbosity) {
+		params.text = { verbosity: options?.textVerbosity ?? model.defaultVerbosity ?? "low" };
+	}
+	if (hasCodexInteractionDefaults) {
+		params.client_metadata = normalizeClientMetadata(options?.metadata);
+	}
+
 	return { conversationMessages, params };
 }
 

package/src/stream.ts

@@ -293,6 +293,7 @@ export const ANTHROPIC_THINKING: Record<Effort, number> = {
 	high: 16384,
 	xhigh: 32768,
 	max: 65536,
+	ultra: 65536,
 };
 
 const GOOGLE_THINKING: Record<Effort, number> = {
@@ -303,6 +304,7 @@ const GOOGLE_THINKING: Record<Effort, number> = {
 	xhigh: 24575,
 	// Google caps the thinking budget here; `max` cannot exceed it.
 	max: 24575,
+	ultra: 24575,
 };
 
 const BEDROCK_CLAUDE_THINKING: Record<Effort, number> = {
@@ -313,6 +315,7 @@ const BEDROCK_CLAUDE_THINKING: Record<Effort, number> = {
 	xhigh: 16384,
 	// Bedrock Claude caps the thinking budget here; `max` cannot exceed it.
 	max: 16384,
+	ultra: 16384,
 };
 
 function resolveBedrockThinkingBudget(
@@ -536,7 +539,10 @@ export function mapOptionsForApi<TApi extends Api>(
 		case "openai-responses":
 			return castApi<"openai-responses">({
 				...base,
-				reasoning: resolveOpenAiReasoningEffort(model, options),
+				reasoning:
+					model.defaultReasoningSummary !== undefined
+						? resolveCodexReasoningEffort(model, options)
+						: resolveOpenAiReasoningEffort(model, options),
 				toolChoice: mapOpenAiToolChoice(options?.toolChoice),
 				serviceTier: options?.serviceTier,
 			});

package/src/types.ts

@@ -12,7 +12,6 @@ import type {
 	GrepResult,
 	LsArgs,
 	LsResult,
-	McpResult,
 	ReadArgs,
 	ReadResult,
 	ShellArgs,
@@ -222,7 +221,7 @@ export interface StreamOptions {
 	 * Set to 0 to disable the first-event watchdog for this request.
 	 */
 	streamFirstEventTimeoutMs?: number;
-	/** Cursor exec/MCP tool handlers (cursor-agent only). */
+	/** Cursor generic execution handlers (cursor-agent only). */
 	execHandlers?: CursorExecHandlers;
 }
 
@@ -428,7 +427,8 @@ export type CursorToolResultHandler = (
 	result: ToolResultMessage,
 ) => ToolResultMessage | undefined | Promise<ToolResultMessage | undefined>;
 
-export interface CursorMcpCall {
+/** A generic tool request transported by the Cursor agent protocol. */
+export interface CursorToolCall {
 	name: string;
 	providerIdentifier: string;
 	toolName: string;
@@ -454,7 +454,7 @@ export interface CursorExecHandlers {
 		callbacks: CursorShellStreamCallbacks,
 	) => Promise<CursorExecHandlerResult<ShellResult>>;
 	diagnostics?: (args: DiagnosticsArgs) => Promise<CursorExecHandlerResult<DiagnosticsResult>>;
-	mcp?: (call: CursorMcpCall) => Promise<CursorExecHandlerResult<McpResult>>;
+	tool?: (call: CursorToolCall) => Promise<CursorExecHandlerResult<unknown>>;
 	onToolResult?: CursorToolResultHandler;
 }
 
@@ -620,6 +620,24 @@ export interface Model<TApi extends Api = any> {
 	premiumMultiplier?: number;
 	contextWindow: number;
 	maxTokens: number;
+	/** Largest context accepted by the Codex interaction contract. */
+	maxContextWindow?: number;
+	/** Live provider-advertised input limit, retained independently from the selected tier. */
+	providerContextWindow?: number;
+	/** Percentage of the selected context window available to request input. */
+	effectiveContextWindowPercent?: number;
+	/** Resolved usable input budget for the selected context tier. */
+	effectiveContextWindow?: number;
+	/** Percentage of the selected context window that triggers automatic compaction. */
+	autoCompactThresholdPercent?: number;
+	/** Resolved automatic-compaction threshold for the selected context tier. */
+	autoCompactTokenLimit?: number;
+	defaultReasoningSummary?: "none" | "auto" | "concise" | "detailed";
+	defaultVerbosity?: "low" | "medium" | "high";
+	serviceTiers?: ServiceTier[];
+	defaultServiceTier?: ServiceTier;
+	truncationPolicy?: { mode: "tokens" | "bytes"; limit: number };
+	supportsParallelToolCalls?: boolean;
 	headers?: Record<string, string>;
 	/**
 	 * Extra anthropic-beta feature flags to send for this model (anthropic-messages API only).

package/src/utils/discovery/codex.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { applyCodexInteractionMetadata } from "../../codex-model-interaction";
 import { REASONING_EFFORTS, type ReasoningEffort } from "../../model-thinking";
 import { CODEX_BASE_URL, OPENAI_HEADER_VALUES, OPENAI_HEADERS } from "../../providers/openai-codex/constants";
 import type { Model, ThinkingConfig } from "../../types";
@@ -28,6 +29,15 @@ const codexModelEntrySchema = z
 		family: z.unknown().optional(),
 		tier: z.unknown().optional(),
 		context_window: z.unknown().optional(),
+		max_context_window: z.unknown().optional(),
+		auto_compact_token_limit: z.unknown().optional(),
+		effective_context_window_percent: z.unknown().optional(),
+		default_reasoning_summary: z.unknown().optional(),
+		default_verbosity: z.unknown().optional(),
+		service_tiers: z.unknown().optional(),
+		default_service_tier: z.unknown().optional(),
+		truncation_policy: z.unknown().optional(),
+		supports_parallel_tool_calls: z.unknown().optional(),
 		default_reasoning_level: z.unknown().optional(),
 		supported_reasoning_levels: z.unknown().optional(),
 		input_modalities: z.unknown().optional(),
@@ -266,6 +276,7 @@ function normalizeCodexModelEntry(entry: unknown, baseUrl: string): NormalizedCo
 
 	const name = toNonEmptyString(payload.display_name) ?? slug;
 	const contextWindow = toPositiveInt(payload.context_window) ?? DEFAULT_CONTEXT_WINDOW;
+	const providerContextWindow = toPositiveInt(payload.max_context_window) ?? contextWindow;
 	const maxTokens = Math.min(DEFAULT_MAX_TOKENS, contextWindow);
 	const thinking = normalizeReasoningConfig(payload.default_reasoning_level, payload.supported_reasoning_levels);
 	const reasoning = Boolean(thinking?.supportedLevels.some(level => level.effort !== "none"));
@@ -277,24 +288,28 @@ function normalizeCodexModelEntry(entry: unknown, baseUrl: string): NormalizedCo
 
 	return {
 		priority,
-		model: {
-			id: slug,
-			name,
-			api: "openai-codex-responses",
-			provider: "openai-codex",
-			baseUrl,
-			reasoning,
-			input,
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-			contextWindow,
-			maxTokens,
-			...(toNonEmptyString(payload.description) ? { description: toNonEmptyString(payload.description)! } : {}),
-			...(visibility ? { visibility } : {}),
-			...presentation,
-			...(thinking ? { thinking } : {}),
-			...(preferWebsockets ? { preferWebsockets: true } : {}),
-			...(priority !== Number.MAX_SAFE_INTEGER ? { priority } : {}),
-		},
+		model: applyCodexInteractionMetadata(
+			{
+				id: slug,
+				name,
+				api: "openai-codex-responses",
+				provider: "openai-codex",
+				baseUrl,
+				reasoning,
+				input,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+				contextWindow,
+				maxTokens,
+				providerContextWindow,
+				...(toNonEmptyString(payload.description) ? { description: toNonEmptyString(payload.description)! } : {}),
+				...(visibility ? { visibility } : {}),
+				...presentation,
+				...(thinking ? { thinking } : {}),
+				...(preferWebsockets ? { preferWebsockets: true } : {}),
+				...(priority !== Number.MAX_SAFE_INTEGER ? { priority } : {}),
+			},
+			providerContextWindow,
+		),
 	};
 }
 

package/src/utils/schema/sanitize-google.ts

@@ -181,14 +181,14 @@ export function sanitizeSchemaForCCA(value: unknown): unknown {
 }
 
 /**
- * Fields stripped for MCP/AJV compatibility.
+ * Fields stripped for AJV compatibility.
  * Only `$schema` — AJV throws on unrecognised meta-schema URIs
  * (e.g. draft 2020-12 emitted by schemars 1.x / rmcp 0.15+).
  */
-const MCP_UNSUPPORTED_SCHEMA_FIELDS = new Set(["$schema"]);
+const AJV_UNSUPPORTED_SCHEMA_FIELDS = new Set(["$schema"]);
 
 /**
- * Sanitize a JSON Schema for MCP tool parameter validation (AJV compatibility).
+ * Sanitize a JSON Schema for tool parameter validation (AJV compatibility).
  *
  * Strips only the minimal set of fields that cause AJV validation errors:
  * - `$schema`: AJV throws on unknown meta-schema URIs.
@@ -198,7 +198,7 @@ const MCP_UNSUPPORTED_SCHEMA_FIELDS = new Set(["$schema"]);
  * (`pattern`, `format`, `additionalProperties`, etc.) and `$ref`/`$defs`.
  */
 export function sanitizeSchemaForMCP(value: unknown): unknown {
-	// Dereference $ref/$defs first — MCP servers emit standard JSON Schema
+	// Dereference $ref/$defs first because providers emit standard JSON Schema.
 	// with $defs, but providers (Anthropic, Google) only forward `properties`
 	// and `required`, dropping $defs and leaving dangling $ref pointers.
 	const dereferenced = dereferenceJsonSchema(value);
@@ -206,7 +206,7 @@ export function sanitizeSchemaForMCP(value: unknown): unknown {
 		insideProperties: false,
 		normalizeTypeArrayToNullable: false,
 		stripNullableKeyword: true,
-		unsupportedFields: MCP_UNSUPPORTED_SCHEMA_FIELDS,
+		unsupportedFields: AJV_UNSUPPORTED_SCHEMA_FIELDS,
 		seen: new WeakSet(),
 	});
 }

package/src/utils/validation.ts

@@ -513,7 +513,7 @@ function coerceArgsFromErrors(
 // Create a singleton AJV instance with formats (only if not in browser extension)
 // AJV requires 'unsafe-eval' CSP which is not allowed in Manifest V3
 //
-// Silent logger: MCP servers may declare non-standard format keywords (e.g. "uint")
+// Silent logger: external tool schemas may declare non-standard format keywords (e.g. "uint").
 // which cause Ajv to emit console.warn() with strict:false — corrupting TUI output.
 const ajv = new Ajv({
 	allErrors: false,