@f5-sales-demo/pi-ai 19.51.2

package/src/utils/schema/equality.ts

@@ -0,0 +1,93 @@
+import type { JsonObject } from "./types";
+import { isJsonObject } from "./types";
+
+export function areJsonValuesEqual(left: unknown, right: unknown): boolean {
+	if (Object.is(left, right)) {
+		return true;
+	}
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+			return false;
+		}
+		for (let i = 0; i < left.length; i += 1) {
+			if (!areJsonValuesEqual(left[i], right[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+	if (!isJsonObject(left) || !isJsonObject(right)) {
+		return false;
+	}
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) {
+		return false;
+	}
+	for (const key of leftKeys) {
+		if (!(key in right) || !areJsonValuesEqual(left[key], right[key])) {
+			return false;
+		}
+	}
+	return true;
+}
+
+export function mergeCompatibleEnumSchemas(existing: unknown, incoming: unknown): JsonObject | null {
+	if (!isJsonObject(existing) || !isJsonObject(incoming)) {
+		return null;
+	}
+	const existingEnum = Array.isArray(existing.enum) ? existing.enum : null;
+	const incomingEnum = Array.isArray(incoming.enum) ? incoming.enum : null;
+	if (!existingEnum || !incomingEnum) {
+		return null;
+	}
+	if (!areJsonValuesEqual(existing.type, incoming.type)) {
+		return null;
+	}
+	const existingKeys = Object.keys(existing).filter(key => key !== "enum");
+	const incomingKeys = Object.keys(incoming).filter(key => key !== "enum");
+	if (existingKeys.length !== incomingKeys.length) {
+		return null;
+	}
+	for (const key of existingKeys) {
+		if (!(key in incoming) || !areJsonValuesEqual(existing[key], incoming[key])) {
+			return null;
+		}
+	}
+
+	const mergedEnum = [...existingEnum];
+	for (const enumValue of incomingEnum) {
+		if (!mergedEnum.some(existingValue => areJsonValuesEqual(existingValue, enumValue))) {
+			mergedEnum.push(enumValue);
+		}
+	}
+	return {
+		...existing,
+		enum: mergedEnum,
+	};
+}
+
+function getAnyOfVariants(schema: unknown): unknown[] {
+	if (isJsonObject(schema) && Array.isArray(schema.anyOf)) {
+		return schema.anyOf;
+	}
+	return [schema];
+}
+
+export function mergePropertySchemas(existing: unknown, incoming: unknown): unknown {
+	if (areJsonValuesEqual(existing, incoming)) {
+		return existing;
+	}
+	const mergedEnumSchema = mergeCompatibleEnumSchemas(existing, incoming);
+	if (mergedEnumSchema !== null) {
+		return mergedEnumSchema;
+	}
+
+	const mergedAnyOf = [...getAnyOfVariants(existing)];
+	for (const variant of getAnyOfVariants(incoming)) {
+		if (!mergedAnyOf.some(existingVariant => areJsonValuesEqual(existingVariant, variant))) {
+			mergedAnyOf.push(variant);
+		}
+	}
+	return mergedAnyOf.length === 1 ? mergedAnyOf[0] : { anyOf: mergedAnyOf };
+}

package/src/utils/schema/fields.ts

@@ -0,0 +1,147 @@
+/**
+ * Field classification sets for JSON Schema sanitization across providers.
+ *
+ * Each set serves a different provider need. They overlap intentionally —
+ * co-locating them makes the overlap visible and maintainable.
+ */
+
+/**
+ * Google Generative AI unsupported schema fields.
+ * Stripped during sanitizeSchemaForGoogle / sanitizeSchemaForCCA.
+ */
+export const UNSUPPORTED_SCHEMA_FIELDS = new Set([
+	"$schema",
+	"$ref",
+	"$defs",
+	"$dynamicRef",
+	"$dynamicAnchor",
+	"examples",
+	"prefixItems",
+	"unevaluatedProperties",
+	"unevaluatedItems",
+	"patternProperties",
+	"additionalProperties",
+	"minItems",
+	"maxItems",
+	"minLength",
+	"maxLength",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"pattern",
+	"format",
+]);
+
+/**
+ * Non-structural schema keys stripped during OpenAI strict mode sanitization.
+ * These are decorative/validation-only keywords that don't affect the structural
+ * shape OpenAI's strict mode enforces.
+ */
+export const NON_STRUCTURAL_SCHEMA_KEYS = new Set([
+	"format",
+	"pattern",
+	"minLength",
+	"maxLength",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"minItems",
+	"maxItems",
+	"uniqueItems",
+	"multipleOf",
+	"$schema",
+	"examples",
+	"default",
+	"title",
+	"$comment",
+	"if",
+	"then",
+	"else",
+	"not",
+	"prefixItems",
+	"unevaluatedProperties",
+	"unevaluatedItems",
+	"patternProperties",
+	"propertyNames",
+	"contains",
+	"minContains",
+	"maxContains",
+	"dependentRequired",
+	"dependentSchemas",
+	"contentEncoding",
+	"contentMediaType",
+	"contentSchema",
+	"deprecated",
+	"readOnly",
+	"writeOnly",
+	"minProperties",
+	"maxProperties",
+	"$dynamicRef",
+	"$dynamicAnchor",
+]);
+
+/**
+ * Cloud Code Assist type-specific allowed keys per JSON Schema type.
+ * Used when collapsing mixed-type combiner variants for CCA Claude.
+ */
+export const CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS: Record<string, ReadonlySet<string>> = {
+	array: new Set([
+		"items",
+		"prefixItems",
+		"contains",
+		"minContains",
+		"maxContains",
+		"minItems",
+		"maxItems",
+		"uniqueItems",
+		"unevaluatedItems",
+	]),
+	object: new Set([
+		"properties",
+		"required",
+		"additionalProperties",
+		"patternProperties",
+		"propertyNames",
+		"minProperties",
+		"maxProperties",
+		"dependentRequired",
+		"dependentSchemas",
+		"unevaluatedProperties",
+	]),
+	string: new Set(["minLength", "maxLength", "pattern", "format", "contentEncoding", "contentMediaType"]),
+	number: new Set(["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"]),
+	integer: new Set(["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"]),
+	boolean: new Set(),
+	null: new Set(),
+};
+
+/**
+ * Cloud Code Assist shared schema keys allowed on any type.
+ * Used alongside CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS for CCA combiner collapsing.
+ */
+export const CLOUD_CODE_ASSIST_SHARED_SCHEMA_KEYS = new Set([
+	"title",
+	"description",
+	"default",
+	"examples",
+	"deprecated",
+	"readOnly",
+	"writeOnly",
+	"$comment",
+]);
+
+/**
+ * Combinator keys used across schema sanitization modules.
+ * Defined once to avoid duplication in strict-mode.ts and normalize-cca.ts.
+ */
+export const COMBINATOR_KEYS = ["anyOf", "allOf", "oneOf"] as const;
+
+/**
+ * Cloud Code Assist Claude unsupported schema fields.
+ * Much smaller than UNSUPPORTED_SCHEMA_FIELDS (Google) because CCA supports
+ * validation keywords like additionalProperties, minLength, pattern, etc.
+ * Only meta/reference keywords that CCA cannot resolve are stripped.
+ */
+export const CCA_UNSUPPORTED_SCHEMA_FIELDS = new Set(["$schema", "$ref", "$defs", "$dynamicRef", "$dynamicAnchor"]);

package/src/utils/schema/index.ts

@@ -0,0 +1,9 @@
+export * from "./adapt";
+export * from "./compatibility";
+export * from "./dereference";
+export * from "./equality";
+export * from "./fields";
+export * from "./normalize-cca";
+export * from "./sanitize-google";
+export * from "./strict-mode";
+export * from "./types";