ai-platform-converter
Version:
Lossless API parameter conversion between multiple AI platforms (OpenAI, Anthropic, Gemini, DeepSeek, Wenwen, Vertex AI, Huawei, BigModel)
356 lines (355 loc) • 12.5 kB
JavaScript
"use strict";
/**
* API Compliance Validation Utility
*
* This utility validates converter compliance with 2025 API standards
* for all supported AI platforms.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAnthropicCompliance = validateAnthropicCompliance;
exports.validateOpenAICompliance = validateOpenAICompliance;
exports.validateGeminiCompliance = validateGeminiCompliance;
exports.validateDeepSeekCompliance = validateDeepSeekCompliance;
exports.generateComplianceReport = generateComplianceReport;
/**
* Validate Anthropic API compliance
*/
function validateAnthropicCompliance(request) {
const errors = [];
const warnings = [];
// Check required fields
if (!request.model) {
errors.push({
field: 'model',
message: 'Model is required',
severity: 'error'
});
}
if (!request.messages || request.messages.length === 0) {
errors.push({
field: 'messages',
message: 'Messages array is required and cannot be empty',
severity: 'error'
});
}
if (typeof request.max_tokens !== 'number' || request.max_tokens <= 0) {
errors.push({
field: 'max_tokens',
message: 'max_tokens must be a positive number',
severity: 'error'
});
}
// Validate 2025 new parameters
if (request.container) {
if (typeof request.container === 'object') {
if (request.container.container_type && !['message', 'conversation'].includes(request.container.container_type)) {
errors.push({
field: 'container.container_type',
message: 'container_type must be "message" or "conversation"',
severity: 'error',
apiVersion: '2025'
});
}
}
}
if (request.thinking) {
if (request.thinking.max_thinking_time && request.thinking.max_thinking_time < 0) {
errors.push({
field: 'thinking.max_thinking_time',
message: 'max_thinking_time must be non-negative',
severity: 'error',
apiVersion: '2025'
});
}
if (request.thinking.thinking_budget_tokens && request.thinking.thinking_budget_tokens < 0) {
errors.push({
field: 'thinking.thinking_budget_tokens',
message: 'thinking_budget_tokens must be non-negative',
severity: 'error',
apiVersion: '2025'
});
}
}
if (request.mcp_servers && request.mcp_servers.length > 20) {
errors.push({
field: 'mcp_servers',
message: 'Maximum 20 MCP servers allowed',
severity: 'error',
apiVersion: '2025'
});
}
if (request.service_tier && !['auto', 'standard_only'].includes(request.service_tier)) {
errors.push({
field: 'service_tier',
message: 'service_tier must be "auto" or "standard_only"',
severity: 'error',
apiVersion: '2025'
});
}
// Validate parameter ranges
if (request.temperature !== undefined && (request.temperature < 0 || request.temperature > 1)) {
errors.push({
field: 'temperature',
message: 'Temperature must be between 0 and 1',
severity: 'error'
});
}
if (request.top_p !== undefined && (request.top_p < 0 || request.top_p > 1)) {
errors.push({
field: 'top_p',
message: 'top_p must be between 0 and 1',
severity: 'error'
});
}
if (request.top_k !== undefined && request.top_k < 0) {
errors.push({
field: 'top_k',
message: 'top_k must be non-negative',
severity: 'error'
});
}
return {
isValid: errors.length === 0,
errors,
warnings,
platform: 'Anthropic',
timestamp: new Date()
};
}
/**
* Validate OpenAI API compliance
*/
function validateOpenAICompliance(request) {
const errors = [];
const warnings = [];
// Check required fields
if (!request.model) {
errors.push({
field: 'model',
message: 'Model is required',
severity: 'error'
});
}
if (!request.messages || request.messages.length === 0) {
errors.push({
field: 'messages',
message: 'Messages array is required and cannot be empty',
severity: 'error'
});
}
// Validate parameter ranges
if (request.temperature !== undefined && (request.temperature < 0 || request.temperature > 2)) {
errors.push({
field: 'temperature',
message: 'Temperature must be between 0 and 2',
severity: 'error'
});
}
if (request.top_p !== undefined && (request.top_p < 0 || request.top_p > 1)) {
errors.push({
field: 'top_p',
message: 'top_p must be between 0 and 1',
severity: 'error'
});
}
if (request.max_tokens !== undefined && request.max_tokens <= 0) {
errors.push({
field: 'max_tokens',
message: 'max_tokens must be positive',
severity: 'error'
});
}
// Validate tool configuration
if (request.tool_choice === 'required' && !request.tools) {
warnings.push({
field: 'tool_choice',
message: 'tool_choice is "required" but no tools are provided',
recommendation: 'Provide tools or change tool_choice to "auto"'
});
}
return {
isValid: errors.length === 0,
errors,
warnings,
platform: 'OpenAI',
timestamp: new Date()
};
}
/**
* Validate Gemini API compliance
*/
function validateGeminiCompliance(request) {
const errors = [];
const warnings = [];
// Check required fields
if (!request.contents || request.contents.length === 0) {
errors.push({
field: 'contents',
message: 'Contents array is required and cannot be empty',
severity: 'error'
});
}
// Validate generation config
if (request.generationConfig) {
const config = request.generationConfig;
if (config.temperature !== undefined && (config.temperature < 0 || config.temperature > 2)) {
errors.push({
field: 'generationConfig.temperature',
message: 'Temperature must be between 0 and 2',
severity: 'error'
});
}
if (config.topP !== undefined && (config.topP < 0 || config.topP > 1)) {
errors.push({
field: 'generationConfig.topP',
message: 'topP must be between 0 and 1',
severity: 'error'
});
}
if (config.topK !== undefined && config.topK < 0) {
errors.push({
field: 'generationConfig.topK',
message: 'topK must be non-negative',
severity: 'error'
});
}
if (config.maxOutputTokens !== undefined && config.maxOutputTokens <= 0) {
errors.push({
field: 'generationConfig.maxOutputTokens',
message: 'maxOutputTokens must be positive',
severity: 'error'
});
}
if (config.candidateCount !== undefined && config.candidateCount < 1) {
errors.push({
field: 'generationConfig.candidateCount',
message: 'candidateCount must be at least 1',
severity: 'error'
});
}
}
// Validate safety settings
if (request.safetySettings) {
const validCategories = [
'HARM_CATEGORY_HARASSMENT',
'HARM_CATEGORY_HATE_SPEECH',
'HARM_CATEGORY_SEXUALLY_EXPLICIT',
'HARM_CATEGORY_DANGEROUS_CONTENT'
];
const validThresholds = [
'BLOCK_NONE',
'BLOCK_ONLY_HIGH',
'BLOCK_MEDIUM_AND_ABOVE',
'BLOCK_LOW_AND_ABOVE'
];
for (const setting of request.safetySettings) {
if (!validCategories.includes(setting.category)) {
errors.push({
field: 'safetySettings.category',
message: `Invalid safety category: ${setting.category}`,
severity: 'error'
});
}
if (!validThresholds.includes(setting.threshold)) {
errors.push({
field: 'safetySettings.threshold',
message: `Invalid safety threshold: ${setting.threshold}`,
severity: 'error'
});
}
}
}
return {
isValid: errors.length === 0,
errors,
warnings,
platform: 'Gemini',
timestamp: new Date()
};
}
/**
* Validate DeepSeek API compliance
*/
function validateDeepSeekCompliance(request) {
const errors = [];
const warnings = [];
// Check model validity
const validModels = ['deepseek-chat', 'deepseek-coder', 'deepseek-reasoner'];
if (!validModels.includes(request.model)) {
errors.push({
field: 'model',
message: `Invalid model: ${request.model}. Must be one of: ${validModels.join(', ')}`,
severity: 'error'
});
}
// Validate reasoning config for reasoner model
if (request.model === 'deepseek-reasoner' && request.reasoning_config) {
if (request.reasoning_config.max_reasoning_tokens && request.reasoning_config.max_reasoning_tokens < 0) {
errors.push({
field: 'reasoning_config.max_reasoning_tokens',
message: 'max_reasoning_tokens must be non-negative',
severity: 'error'
});
}
if (request.reasoning_config.temperature !== undefined &&
(request.reasoning_config.temperature < 0 || request.reasoning_config.temperature > 1)) {
errors.push({
field: 'reasoning_config.temperature',
message: 'reasoning_config.temperature must be between 0 and 1',
severity: 'error'
});
}
}
// Warn about beta features
if (request.prefix_completion) {
warnings.push({
field: 'prefix_completion',
message: 'prefix_completion is a beta feature and requires beta endpoint',
recommendation: 'Ensure you are using the beta API endpoint'
});
}
return {
isValid: errors.length === 0,
errors,
warnings,
platform: 'DeepSeek',
timestamp: new Date()
};
}
/**
* Generate comprehensive compliance report
*/
function generateComplianceReport(anthropicRequest, openaiRequest, geminiRequest, deepseekRequest) {
const platformResults = [];
if (anthropicRequest) {
platformResults.push(validateAnthropicCompliance(anthropicRequest));
}
if (openaiRequest) {
platformResults.push(validateOpenAICompliance(openaiRequest));
}
if (geminiRequest) {
platformResults.push(validateGeminiCompliance(geminiRequest));
}
if (deepseekRequest) {
platformResults.push(validateDeepSeekCompliance(deepseekRequest));
}
// Count validation checks performed (basic validations + parameter validations)
const basicChecks = platformResults.length * 2; // At least 2 basic checks per platform
const parameterChecks = platformResults.reduce((sum, result) => sum + result.errors.length + result.warnings.length, 0);
const totalChecks = basicChecks + parameterChecks;
const failedChecks = platformResults.reduce((sum, result) => sum + result.errors.length, 0);
const warnings = platformResults.reduce((sum, result) => sum + result.warnings.length, 0);
const passedChecks = totalChecks - failedChecks;
const allValid = platformResults.every(result => result.isValid);
const summary = allValid
? 'All platforms are compliant with 2025 API standards'
: `${failedChecks} compliance issues found across platforms`;
return {
totalChecks,
passedChecks,
failedChecks,
warnings,
platformResults,
summary
};
}