Remove unused functions from schemaCompressor.ts

- Removed TOKENS_PER_CHARACTER constant (unused)
- Removed SchemaCompressionResult interface (only used by removed functions)
- Removed estimateTokens() function (only used internally by removed functions)
- Removed compressSchemaWithMetrics() function (only used in tests)
- Removed compressToolSchemas() function (only used in tests)
- Updated test file to remove corresponding test blocks and imports
- Reduced file from 248 to ~150 lines, removing ~100 lines of unused code
- Core functionality preserved: jsonSchemaToXml, escapeXml, getCompactType remain
- All tests passing

Author: shariqriazz

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

@@ -1,7 +1,7 @@
 // npx vitest core/prompts/utils/__tests__/schemaCompressor.spec.ts
 
 import { describe, it, expect } from "vitest"
-import { jsonSchemaToXml, compressSchemaWithMetrics, compressToolSchemas } from "../schemaCompressor"
+import { jsonSchemaToXml } from "../schemaCompressor"
 
 describe("schemaCompressor", () => {
 	describe("jsonSchemaToXml", () => {
@@ -317,133 +317,6 @@ describe("schemaCompressor", () => {
 		})
 	})
 
-	describe("compressSchemaWithMetrics", () => {
-		it("should calculate compression metrics", () => {
-			const schema = {
-				type: "object",
-				properties: {
-					query: {
-						type: "string",
-						description: "The natural language question to answer using web search.",
-					},
-				},
-				required: ["query"],
-			}
-
-			const result = compressSchemaWithMetrics(schema)
-
-			expect(result.compressed).toBe("<schema>query*:string</schema>")
-			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", () => {
-		it("should compress multiple tools and calculate total metrics", () => {
-			const tools = [
-				{
-					name: "search",
-					inputSchema: {
-						type: "object" as const,
-						properties: {
-							query: { type: "string" as const },
-						},
-						required: ["query"],
-					},
-				},
-				{
-					name: "translate",
-					inputSchema: {
-						type: "object" as const,
-						properties: {
-							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 as Array<{ name: string; inputSchema?: any }>)
-
-			expect(result.compressedTools).toHaveLength(2)
-			expect(result.compressedTools[0].compressedSchema).toBe("<schema>query*:string</schema>")
-			expect(result.compressedTools[1].compressedSchema).toBe(
-				"<schema>text*:string, target_lang*:string, source_lang?:string</schema>",
-			)
-			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", () => {
 		it("should compress google-ai-search-mcp tool schema", () => {
 			const schema = {

src/core/prompts/utils/schemaCompressor.ts

@@ -1,6 +1,5 @@
 // Constants for better maintainability
 const ENUM_DISPLAY_THRESHOLD = 3
-const TOKENS_PER_CHARACTER = 4
 
 // JSON Schema type definitions
 interface JsonSchemaProperty {
@@ -21,13 +20,6 @@ interface JsonSchema {
 	items?: JsonSchemaProperty
 }
 
-export interface SchemaCompressionResult {
-	compressed: string
-	originalTokens: number
-	compressedTokens: number
-	reduction: number
-}
-
 /**
  * Escapes special XML characters to prevent XSS vulnerabilities
  * @param text - The text to escape
@@ -148,100 +140,3 @@ function getCompactType(prop: JsonSchemaProperty | null | undefined): string {
 			return prop.type || "any"
 	}
 }
-
-/**
- * Estimates the number of tokens in a text string
- * Uses a more sophisticated algorithm based on common tokenization patterns
- * @param text - The text to estimate tokens for
- * @returns The estimated number of tokens
- */
-function estimateTokens(text: string): number {
-	// Handle null/undefined/empty strings
-	if (!text) {
-		return 0
-	}
-
-	// More accurate token estimation based on:
-	// - Average English word length is ~4.7 characters
-	// - Punctuation and whitespace add overhead
-	// - JSON structure adds additional tokens
-
-	// Count words (rough approximation)
-	const words = text.split(/\s+/).filter((w) => w.length > 0).length
-
-	// Count special JSON characters that typically become separate tokens
-	const jsonTokens = (text.match(/[{}[\],:]/g) || []).length
-
-	// Estimate based on character count for very short strings
-	if (text.length < 20) {
-		return Math.ceil(text.length / 3)
-	}
-
-	// Combined estimation
-	return Math.ceil(words * 1.3 + jsonTokens * 0.5)
-}
-
-/**
- * Compresses a JSON Schema and provides metrics about the compression
- * @param schema - The JSON Schema to compress
- * @returns Compression result with metrics
- */
-export function compressSchemaWithMetrics(schema: JsonSchema | null | undefined): SchemaCompressionResult {
-	const originalJson = JSON.stringify(schema, null, 2)
-	const compressed = jsonSchemaToXml(schema)
-
-	const originalTokens = estimateTokens(originalJson)
-	const compressedTokens = estimateTokens(compressed)
-
-	// Calculate reduction, ensuring it's never negative
-	let reduction = 0
-	if (originalTokens > 0 && compressedTokens < originalTokens) {
-		reduction = ((originalTokens - compressedTokens) / originalTokens) * 100
-	}
-
-	return {
-		compressed,
-		originalTokens,
-		compressedTokens,
-		reduction: Math.round(reduction),
-	}
-}
-
-/**
- * Compresses multiple tool schemas and calculates aggregate metrics
- * @param tools - Array of tools with optional input schemas
- * @returns Compressed tools with total reduction metrics
- */
-export function compressToolSchemas(tools: Array<{ name: string; inputSchema?: JsonSchema }>): {
-	compressedTools: Array<{ name: string; compressedSchema: string }>
-	totalReduction: number
-	originalTokens: number
-	compressedTokens: number
-} {
-	let totalOriginalTokens = 0
-	let totalCompressedTokens = 0
-
-	const compressedTools = tools.map((tool) => {
-		const result = compressSchemaWithMetrics(tool.inputSchema)
-		totalOriginalTokens += result.originalTokens
-		totalCompressedTokens += result.compressedTokens
-
-		return {
-			name: tool.name,
-			compressedSchema: result.compressed,
-		}
-	})
-
-	// Calculate total reduction, ensuring it's never negative
-	let totalReduction = 0
-	if (totalOriginalTokens > 0 && totalCompressedTokens < totalOriginalTokens) {
-		totalReduction = Math.round(((totalOriginalTokens - totalCompressedTokens) / totalOriginalTokens) * 100)
-	}
-
-	return {
-		compressedTools,
-		totalReduction,
-		originalTokens: totalOriginalTokens,
-		compressedTokens: totalCompressedTokens,
-	}
-}