@z_ai/mcp-server/build/core/environment.js

MCP Server for Z.AI - A Model Context Protocol server that provides AI capabilities

import * as fs from 'fs';
import * as path from 'path';
import * as dotenv from 'dotenv';
import { ApiError } from '../types/index.js';
/**
 * Environment configuration service using singleton pattern
 */
export class EnvironmentService {
    static instance;
    config = null;
    constructor() { }
    /**
     * Get singleton instance of EnvironmentService
     */
    static getInstance() {
        if (!EnvironmentService.instance) {
            EnvironmentService.instance = new EnvironmentService();
        }
        return EnvironmentService.instance;
    }
    /**
     * Get environment configuration
     */
    getConfig() {
        if (!this.config) {
            this.config = this.loadEnvironmentConfig();
        }
        return this.config;
    }
    /**
     * Load environment configuration from .env files and process.env
     */
    loadEnvironmentConfig() {
        const envConfig = { ...process.env };
        const envPaths = [
            path.join(process.cwd(), '.env'),
            path.join(path.dirname(import.meta.dirname), '..', '.env'),
        ];
        for (const envPath of envPaths) {
            if (fs.existsSync(envPath)) {
                const env = dotenv.parse(fs.readFileSync(envPath));
                Object.assign(envConfig, env);
                console.debug('Loaded environment file', { path: envPath });
            }
        }
        if (!envConfig.Z_AI_BASE_URL) {
            // for z.ai paas is https://api.z.ai/api/paas/v4/
            // for zhipuai is https://open.bigmodel.cn/api/paas/v4/
            envConfig.Z_AI_BASE_URL = 'https://api.z.ai/api/paas/v4/';
        }
        if (envConfig.PLATFORM_MODE != null) {
            console.info('Running in mode', { mode: envConfig.PLATFORM_MODE });
            if (envConfig.PLATFORM_MODE === 'Z_AI' || envConfig.PLATFORM_MODE === 'ZAI' || envConfig.PLATFORM_MODE === 'Z') {
                envConfig.Z_AI_BASE_URL = 'https://api.z.ai/api/paas/v4/';
                envConfig.PLATFORM_MODE = 'ZAI';
            }
            else if (envConfig.PLATFORM_MODE === 'ZHIPU_AI' || envConfig.PLATFORM_MODE === 'ZHIPUAI'
                || envConfig.PLATFORM_MODE === 'ZHIPU' || envConfig.PLATFORM_MODE === 'BIGMODEL') {
                envConfig.Z_AI_BASE_URL = 'https://open.bigmodel.cn/api/paas/v4/';
                envConfig.PLATFORM_MODE = 'ZHIPU';
            }
        }
        else {
            envConfig.PLATFORM_MODE = 'ZHIPU';
        }
        if (!envConfig.Z_AI_API_KEY) {
            throw new ApiError('ZAI_API_KEY environment variable is required');
        }
        return {
            Z_AI_BASE_URL: envConfig.Z_AI_BASE_URL,
            Z_AI_API_KEY: envConfig.Z_AI_API_KEY,
            Z_AI_VISION_MODEL: envConfig.Z_AI_VISION_MODEL,
            Z_AI_VIDEO_MODEL: envConfig.Z_AI_VIDEO_MODEL,
            Z_AI_IMAGE_MODEL: envConfig.Z_AI_IMAGE_MODEL,
            Z_AI_TIMEOUT: envConfig.Z_AI_TIMEOUT,
            Z_AI_RETRY_COUNT: envConfig.Z_AI_RETRY_COUNT,
            Z_AI_TEMPERATURE: envConfig.Z_AI_TEMPERATURE,
            Z_AI_TOP_P: envConfig.Z_AI_TOP_P,
            Z_AI_MAX_TOKENS: envConfig.Z_AI_MAX_TOKENS,
            SERVER_NAME: envConfig.SERVER_NAME,
            SERVER_VERSION: envConfig.SERVER_VERSION,
            PLATFORM_MODE: envConfig.PLATFORM_MODE
        };
    }
    /**
     * Get model configuration (implements ConfigurationService)
     */
    getModelConfig(type) {
        const modelName = this.getModelName(type === 'image' ? 'vision' : type === 'video' ? 'vision' : 'image');
        return {
            name: modelName,
            version: '1.0.0',
            capabilities: this.getCapabilitiesForModel(type)
        };
    }
    /**
     * Get capabilities for model type
     */
    getCapabilitiesForModel(type) {
        const capabilityMap = {
            image: ['image_analysis', 'multimodal_understanding'],
            video: ['video_analysis', 'temporal_understanding'],
            generation: ['image_generation', 'creative_synthesis']
        };
        return capabilityMap[type] || [];
    }
    /**
     * Get server configuration
     */
    getServerConfig() {
        const config = this.getConfig();
        return {
            name: config.SERVER_NAME || 'zai-mcp',
            version: config.SERVER_VERSION || '0.1.0'
        };
    }
    /**
     * Get platform mode
     */
    getPlatformModel() {
        const config = this.getConfig();
        return config.PLATFORM_MODE || 'ZHIPU';
    }
    /**
     * Get API configuration
     */
    getVisionConfig() {
        const config = this.getConfig();
        return {
            timeout: parseInt(config.Z_AI_TIMEOUT || '300000'),
            retryCount: parseInt(config.Z_AI_RETRY_COUNT || '2'),
            url: config.Z_AI_BASE_URL + 'chat/completions',
            temperature: parseFloat(config.Z_AI_TEMPERATURE || '0.8'),
            topP: parseFloat(config.Z_AI_TOP_P || '0.6'),
            maxTokens: parseInt(config.Z_AI_MAX_TOKENS || '16384')
        };
    }
    /**
     * Get ZAI API key from configuration
     */
    getApiKey() {
        return this.getConfig().Z_AI_API_KEY;
    }
    /**
     * Get model name for specific type (image, file)
     */
    getModelName(type) {
        const config = this.getConfig();
        const envVar = `Z_AI_${type.toUpperCase()}_MODEL`;
        return config[envVar] || `glm-4.5v`; // Default fallback
    }
}
/**
 * Global environment service instance
 */
export const environmentService = EnvironmentService.getInstance();
/**
 * Configuration service instance (for backward compatibility)
 */
export const configurationService = environmentService;