fix: key Ajv compile cache on stable raw schema, drop dead dialect code

Author: Shkin1

apps/desktop/src/main/runtime-host-native-capabilities.ts

@@ -36,9 +36,7 @@ import {
   type ClientCapabilityServiceOffer,
 } from "@maka/runtime-host/protocol";
 import { validateTypes } from '@ai-sdk/provider-utils';
-import Ajv, { type AnySchema, type ValidateFunction } from 'ajv';
-import Ajv2019 from 'ajv/dist/2019.js';
-import Ajv2020 from 'ajv/dist/2020.js';
+import Ajv2020, { type AnySchema, type ValidateFunction } from 'ajv/dist/2020.js';
 import { toJSONSchema, z } from "zod";
 import { withBrowserOriginAdmission } from './browser/browser-origin-admission.js';
 import type { DesktopTargetScope } from '../shared/runtime-host-identity.js';
@@ -489,35 +487,30 @@ interface JsonSchemaWrapper {
 }
 
 // -- JSON Schema argument validation -------------------------------------------
+//
+// Validation runs against the projected (advertised) schema, not the raw
+// MCP schema, so any constraint expressed via non-whitelisted keywords
+// (if/then/else, contains, dependentRequired, …) is dropped before Ajv
+// sees it. The downstream MCP server re-validates against the full schema.
 
 const jsonSchemaValidatorOptions = {
   allErrors: true,
   strict: false,
   validateFormats: false,
 } as const;
-const draft7Validator = new Ajv(jsonSchemaValidatorOptions);
-const draft2019Validator = new Ajv2019(jsonSchemaValidatorOptions);
-const draft2020Validator = new Ajv2020(jsonSchemaValidatorOptions);
+const schemaValidator = new Ajv2020(jsonSchemaValidatorOptions);
 const compiledSchemas = new WeakMap<object, ValidateFunction>();
 
-function compileJsonSchema(schema: unknown): ValidateFunction | undefined {
-  if (typeof schema === 'boolean') return draft2020Validator.compile(schema);
-  if (typeof schema !== 'object' || schema === null || Array.isArray(schema))
-    return undefined;
-  const cached = compiledSchemas.get(schema);
+function compileJsonSchema(
+  rawSchema: object,
+  projected: Record<string, unknown>,
+): ValidateFunction | undefined {
+  const cached = compiledSchemas.get(rawSchema);
   if (cached) return cached;
-  const declaredDialect = (
-    schema as { readonly $schema?: unknown }
-  ).$schema;
-  const dialect =
-    typeof declaredDialect === 'string' ? declaredDialect : '';
-  const validator = dialect.includes('draft-07')
-    ? draft7Validator
-    : dialect.includes('2019-09')
-      ? draft2019Validator
-      : draft2020Validator;
-  const compiled = validator.compile(schema as AnySchema);
-  compiledSchemas.set(schema, compiled);
+  if (typeof projected !== 'object' || projected === null || Array.isArray(projected))
+    return undefined;
+  const compiled = schemaValidator.compile(projected as AnySchema);
+  compiledSchemas.set(rawSchema, compiled);
   return compiled;
 }
 
@@ -540,10 +533,9 @@ async function parseNativeToolArguments(
   // jsonSchema() wrappers: compile the projected schema and validate.
   const wrapper = parameters as JsonSchemaWrapper | undefined;
   if (wrapper?.jsonSchema) {
-    const projected = projectToolInputSchema(
-      wrapper.jsonSchema as Record<string, unknown>,
-    );
-    const validator = compileJsonSchema(projected);
+    const raw = wrapper.jsonSchema as Record<string, unknown>;
+    const projected = projectToolInputSchema(raw);
+    const validator = compileJsonSchema(raw, projected);
     if (!validator || validator(args)) return args;
     throw new Error(
       `Invalid arguments: ${schemaErrorSummary(validator.errors)}`,