fix: address PR review feedback for schema compression

- Replace all 'any' types with proper TypeScript interfaces (JsonSchema, JsonSchemaProperty)
- Add XML escaping to prevent XSS vulnerabilities in property names and enum values
- Improve token estimation with more sophisticated algorithm
- Add constants for magic numbers (ENUM_DISPLAY_THRESHOLD, TOKENS_PER_CHARACTER)
- Add comprehensive JSDoc documentation for all functions
- Handle edge cases: null/undefined schemas, malformed schemas, nested structures
- Fix reduction calculation to prevent negative values
- Expand test coverage for error scenarios and edge cases
- Add support for additional string formats (uuid, ipv4, ipv6, etc.)
- Show nested object structure for simple objects (≤2 properties)

Author: daniel-lxs

src/core/prompts/utils/__tests__/schemaCompressor.spec.ts

@@ -7,6 +7,7 @@ describe("schemaCompressor", () => {
 	describe("jsonSchemaToXml", () => {
 		it("should handle empty schema", () => {
 			expect(jsonSchemaToXml(null)).toBe("<schema></schema>")
+			expect(jsonSchemaToXml(undefined)).toBe("<schema></schema>")
 			expect(jsonSchemaToXml({})).toBe("<schema></schema>")
 			expect(jsonSchemaToXml({ properties: {} })).toBe("<schema></schema>")
 		})
@@ -74,6 +75,36 @@ describe("schemaCompressor", () => {
 			expect(jsonSchemaToXml(schema)).toBe("<schema>tech_stack*:array[string], numbers?:array[number]</schema>")
 		})
 
+		it("should handle array schema at root level", () => {
+			const schema = {
+				type: "array",
+				items: {
+					type: "string",
+				},
+			}
+
+			expect(jsonSchemaToXml(schema)).toBe("<schema>array[string]</schema>")
+		})
+
+		it("should handle nested array types", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					matrix: {
+						type: "array",
+						items: {
+							type: "array",
+							items: {
+								type: "number",
+							},
+						},
+					},
+				},
+			}
+
+			expect(jsonSchemaToXml(schema)).toBe("<schema>matrix?:array[array[number]]</schema>")
+		})
+
 		it("should handle enum types", () => {
 			const schema = {
 				type: "object",
@@ -93,6 +124,38 @@ describe("schemaCompressor", () => {
 			expect(jsonSchemaToXml(schema)).toBe("<schema>format*:enum(json|xml|csv), size?:enum</schema>")
 		})
 
+		it("should escape XML special characters in enum values", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					operator: {
+						type: "string",
+						enum: ["<", ">", "&", '"', "'"],
+					},
+				},
+			}
+
+			expect(jsonSchemaToXml(schema)).toBe("<schema>operator?:enum</schema>")
+		})
+
+		it("should escape XML special characters in property names", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					"<script>alert('xss')</script>": {
+						type: "string",
+					},
+					"user&admin": {
+						type: "boolean",
+					},
+				},
+			}
+
+			expect(jsonSchemaToXml(schema)).toBe(
+				"<schema>&lt;script&gt;alert(&apos;xss&apos;)&lt;/script&gt;?:string, user&amp;admin?:boolean</schema>",
+			)
+		})
+
 		it("should handle object types", () => {
 			const schema = {
 				type: "object",
@@ -108,7 +171,28 @@ describe("schemaCompressor", () => {
 				required: ["requirements"],
 			}
 
-			expect(jsonSchemaToXml(schema)).toBe("<schema>requirements*:object</schema>")
+			expect(jsonSchemaToXml(schema)).toBe(
+				"<schema>requirements*:object{description:string,scale:string}</schema>",
+			)
+		})
+
+		it("should handle complex nested object types", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					config: {
+						type: "object",
+						properties: {
+							nested1: { type: "string" },
+							nested2: { type: "number" },
+							nested3: { type: "boolean" },
+						},
+					},
+				},
+			}
+
+			// Should simplify to just "object" when more than 2 properties
+			expect(jsonSchemaToXml(schema)).toBe("<schema>config?:object</schema>")
 		})
 
 		it("should handle date and url formats", () => {
@@ -132,6 +216,105 @@ describe("schemaCompressor", () => {
 
 			expect(jsonSchemaToXml(schema)).toBe("<schema>created_date?:date, website?:url, email?:email</schema>")
 		})
+
+		it("should handle additional string formats", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					id: {
+						type: "string",
+						format: "uuid",
+					},
+					timestamp: {
+						type: "string",
+						format: "date-time",
+					},
+					ipv4: {
+						type: "string",
+						format: "ipv4",
+					},
+					ipv6: {
+						type: "string",
+						format: "ipv6",
+					},
+				},
+			}
+
+			expect(jsonSchemaToXml(schema)).toBe(
+				"<schema>id?:uuid, timestamp?:datetime, ipv4?:ipv4, ipv6?:ipv6</schema>",
+			)
+		})
+
+		it("should handle null type", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					nullable_field: {
+						type: "null",
+					},
+				},
+			}
+
+			expect(jsonSchemaToXml(schema)).toBe("<schema>nullable_field?:null</schema>")
+		})
+
+		it("should handle oneOf/anyOf union types", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					union_field: {
+						oneOf: [{ type: "string" }, { type: "number" }],
+					},
+					any_field: {
+						anyOf: [{ type: "boolean" }, { type: "null" }],
+					},
+				},
+			}
+
+			expect(jsonSchemaToXml(schema)).toBe("<schema>union_field?:string|number, any_field?:boolean|null</schema>")
+		})
+
+		it("should handle malformed schemas gracefully", () => {
+			const malformedSchemas = [
+				{ properties: { field: null } },
+				{ properties: { field: "not an object" } },
+				{ properties: { field: [] } },
+				{ properties: { field: { type: [] } } },
+			]
+
+			malformedSchemas.forEach((schema) => {
+				expect(() => jsonSchemaToXml(schema as any)).not.toThrow()
+			})
+		})
+
+		it("should handle arrays without items", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					empty_array: {
+						type: "array",
+					},
+				},
+			}
+
+			expect(jsonSchemaToXml(schema)).toBe("<schema>empty_array?:array[any]</schema>")
+		})
+
+		it("should handle arrays with enum items", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					roles: {
+						type: "array",
+						items: {
+							enum: ["admin", "user", "guest"],
+						},
+					},
+				},
+			}
+
+			expect(jsonSchemaToXml(schema)).toBe("<schema>roles?:array[enum(admin|user|guest)]</schema>")
+		})
 	})
 
 	describe("compressSchemaWithMetrics", () => {
@@ -153,6 +336,48 @@ describe("schemaCompressor", () => {
 			expect(result.originalTokens).toBeGreaterThan(result.compressedTokens)
 			expect(result.reduction).toBeGreaterThan(50) // Should be significant reduction
 		})
+
+		it("should handle null/undefined schemas", () => {
+			const resultNull = compressSchemaWithMetrics(null)
+			const resultUndefined = compressSchemaWithMetrics(undefined)
+
+			expect(resultNull.compressed).toBe("<schema></schema>")
+			expect(resultUndefined.compressed).toBe("<schema></schema>")
+			expect(resultNull.reduction).toBe(0)
+			expect(resultUndefined.reduction).toBe(0)
+		})
+
+		it("should provide accurate token estimation for various text lengths", () => {
+			const shortSchema = { type: "string" }
+			const mediumSchema = {
+				type: "object",
+				properties: {
+					field1: { type: "string" },
+					field2: { type: "number" },
+				},
+			}
+			const longSchema = {
+				type: "object",
+				properties: {
+					field1: { type: "string", description: "A very long description that adds many tokens" },
+					field2: { type: "array", items: { type: "object", properties: { nested: { type: "boolean" } } } },
+					field3: { type: "string", enum: ["option1", "option2", "option3", "option4"] },
+				},
+			}
+
+			const shortResult = compressSchemaWithMetrics(shortSchema)
+			const mediumResult = compressSchemaWithMetrics(mediumSchema)
+			const longResult = compressSchemaWithMetrics(longSchema)
+
+			// Token counts should increase with complexity
+			expect(shortResult.originalTokens).toBeLessThan(mediumResult.originalTokens)
+			expect(mediumResult.originalTokens).toBeLessThan(longResult.originalTokens)
+
+			// All should show reduction
+			expect(shortResult.reduction).toBeGreaterThan(0)
+			expect(mediumResult.reduction).toBeGreaterThan(0)
+			expect(longResult.reduction).toBeGreaterThan(0)
+		})
 	})
 
 	describe("compressToolSchemas", () => {
@@ -161,28 +386,28 @@ describe("schemaCompressor", () => {
 				{
 					name: "search",
 					inputSchema: {
-						type: "object",
+						type: "object" as const,
 						properties: {
-							query: { type: "string" },
+							query: { type: "string" as const },
 						},
 						required: ["query"],
 					},
 				},
 				{
 					name: "translate",
 					inputSchema: {
-						type: "object",
+						type: "object" as const,
 						properties: {
-							text: { type: "string" },
-							target_lang: { type: "string" },
-							source_lang: { type: "string" },
+							text: { type: "string" as const },
+							target_lang: { type: "string" as const },
+							source_lang: { type: "string" as const },
 						},
 						required: ["text", "target_lang"],
 					},
 				},
 			]
 
-			const result = compressToolSchemas(tools)
+			const result = compressToolSchemas(tools as Array<{ name: string; inputSchema?: any }>)
 
 			expect(result.compressedTools).toHaveLength(2)
 			expect(result.compressedTools[0].compressedSchema).toBe("<schema>query*:string</schema>")
@@ -192,6 +417,31 @@ describe("schemaCompressor", () => {
 			expect(result.totalReduction).toBeGreaterThan(0)
 			expect(result.originalTokens).toBeGreaterThan(result.compressedTokens)
 		})
+
+		it("should handle tools without schemas", () => {
+			const tools = [
+				{ name: "tool1", inputSchema: undefined },
+				{ name: "tool2" },
+				{ name: "tool3", inputSchema: null },
+			]
+
+			const result = compressToolSchemas(tools as Array<{ name: string; inputSchema?: any }>)
+
+			expect(result.compressedTools).toHaveLength(3)
+			result.compressedTools.forEach((tool) => {
+				expect(tool.compressedSchema).toBe("<schema></schema>")
+			})
+			expect(result.totalReduction).toBe(0)
+		})
+
+		it("should handle empty tools array", () => {
+			const result = compressToolSchemas([])
+
+			expect(result.compressedTools).toHaveLength(0)
+			expect(result.totalReduction).toBe(0)
+			expect(result.originalTokens).toBe(0)
+			expect(result.compressedTokens).toBe(0)
+		})
 	})
 
 	describe("real MCP server examples", () => {
@@ -243,5 +493,39 @@ describe("schemaCompressor", () => {
 				"<schema>libraryName*:string, sort?:enum(trust_score|last_updated|snippets), minTrustScore?:number, maxTrustScore?:number</schema>",
 			)
 		})
+
+		it("should handle complex real-world schema with nested structures", () => {
+			const schema = {
+				type: "object",
+				properties: {
+					method: {
+						type: "string",
+						enum: ["GET", "POST", "PUT", "DELETE"],
+					},
+					headers: {
+						type: "object",
+						properties: {
+							"Content-Type": { type: "string" },
+							Authorization: { type: "string" },
+						},
+					},
+					body: {
+						oneOf: [{ type: "string" }, { type: "object" }],
+					},
+					timeout: {
+						type: "integer",
+						description: "Request timeout in milliseconds",
+					},
+				},
+				required: ["method"],
+			}
+
+			const result = jsonSchemaToXml(schema)
+			// Enum with 4 values should be simplified to just "enum" based on ENUM_DISPLAY_THRESHOLD = 3
+			expect(result).toContain("method*:enum")
+			expect(result).toContain("headers?:object{Content-Type:string,Authorization:string}")
+			expect(result).toContain("body?:string|object")
+			expect(result).toContain("timeout?:number")
+		})
 	})
 })