evolcore 0.0.35 → 0.0.36

package/dist/config/providers-config.js

@@ -0,0 +1,382 @@
+import { isDeepStrictEqual } from 'node:util';
+import { isIP } from 'node:net';
+const PROHIBITED_PATH_SEGMENTS = new Set(['__proto__', 'prototype', 'constructor']);
+const MULTIPART_DOMAIN_SUFFIXES = new Set(['com.cn', 'net.cn', 'org.cn', 'gov.cn', 'co.uk', 'org.uk', 'ac.uk', 'com.au', 'net.au', 'co.jp', 'co.nz']);
+const PROVIDER_ENV_REFERENCE = /^\$(?:([A-Za-z_][A-Za-z0-9_]*)|\{([A-Za-z_][A-Za-z0-9_]*)\})$/u;
+const PROVIDER_ENV_SYNTAX = /\$\{|\$ENV:|\$[A-Za-z_][A-Za-z0-9_]*/u;
+export function providerEnvironmentVariable(value) {
+    const match = PROVIDER_ENV_REFERENCE.exec(value);
+    return match?.[1] || match?.[2];
+}
+function assertProviderEnvironmentSyntax(value, field) {
+    if (PROVIDER_ENV_SYNTAX.test(value) && !providerEnvironmentVariable(value)) {
+        throw new Error(`${field} must use a whole-field environment reference ($VAR or \${VAR})`);
+    }
+}
+function resolveProviderEnvironmentValue(providerId, field, value) {
+    const variable = providerEnvironmentVariable(value);
+    if (!variable)
+        return value;
+    const resolved = process.env[variable];
+    if (resolved === undefined || !resolved.trim()) {
+        throw new Error(`Provider ${providerId} common.${field} references unset or empty environment variable ${variable}`);
+    }
+    return field === 'baseUrl' ? resolved.trim() : resolved;
+}
+function validProviderBaseUrl(value) {
+    try {
+        const parsed = new URL(value);
+        return ['http:', 'https:'].includes(parsed.protocol) && !parsed.username && !parsed.password && !parsed.hash && !parsed.search;
+    }
+    catch {
+        return false;
+    }
+}
+export function providerNameFromBaseUrl(baseUrl) {
+    const hostname = new URL(baseUrl).hostname.replace(/\.$/u, '');
+    if (isIP(hostname.replace(/^\[|\]$/gu, '')))
+        return hostname;
+    const parts = hostname.split('.');
+    const suffixSize = MULTIPART_DOMAIN_SUFFIXES.has(parts.slice(-2).join('.')) ? 2 : 1;
+    return parts.length > suffixSize ? parts[parts.length - suffixSize - 1] : hostname;
+}
+export function providerNameFromBaseUrlIfStatic(baseUrl) {
+    return providerEnvironmentVariable(baseUrl) ? undefined : providerNameFromBaseUrl(baseUrl);
+}
+export function providerServiceTypeForPurpose(purpose) {
+    return purpose === 'auxiliary' ? 'text' : purpose;
+}
+export function providerServiceTypesForBaseagent(baseagent) {
+    return ['claude', 'codex', 'gemini'].includes(baseagent)
+        ? [baseagent]
+        : [...new Set(['text', baseagent])];
+}
+export function providerServiceTypeForBaseagent(baseagent) {
+    return ['ecagent', 'openclaw', 'hermes'].includes(baseagent) ? 'text' : baseagent;
+}
+function resolveProviderServiceTypeForBaseagent(baseagent, selectedServiceType) {
+    assertSafeRegistrySegment(baseagent, 'baseagent');
+    if (selectedServiceType !== undefined) {
+        assertSafeRegistrySegment(selectedServiceType, 'provider service type');
+        if (!providerServiceTypesForBaseagent(baseagent).includes(selectedServiceType)) {
+            throw new Error(`Provider service ${selectedServiceType} is incompatible with baseagent ${baseagent}`);
+        }
+        return selectedServiceType;
+    }
+    return providerServiceTypeForBaseagent(baseagent);
+}
+const FIXED_STYLES = {
+    claude: 'claude',
+    codex: 'codex',
+    gemini: 'gemini',
+};
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function nonEmpty(value, field) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`${field} must be a non-empty string`);
+    return value.trim();
+}
+function assertSafeRegistrySegment(value, field) {
+    if (!/^[A-Za-z0-9_-]+$/u.test(value) || PROHIBITED_PATH_SEGMENTS.has(value)) {
+        throw new Error(`${field} must be a safe identifier`);
+    }
+}
+function assertFields(value, allowed, field) {
+    if (Object.keys(value).some(key => !allowed.includes(key)))
+        throw new Error(`${field} contains an unsupported field`);
+}
+function stringMap(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value))
+        throw new Error(`${field} must be an object`);
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (!key.trim() || PROHIBITED_PATH_SEGMENTS.has(key) || typeof entry !== 'string')
+            throw new Error(`${field} must contain string values`);
+        if (field.endsWith('.headers') && (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u.test(key) || /[\0\r\n]/u.test(entry))) {
+            throw new Error(`${field} contains an invalid header`);
+        }
+        result[key] = entry;
+    }
+    return result;
+}
+function modelOverride(value, field) {
+    if (!isRecord(value))
+        throw new Error(`${field} must be an object`);
+    assertFields(value, ['enabled', 'name', 'imageIn', 'manual', 'maxInputTokens'], field);
+    const result = {};
+    if (value.enabled !== undefined && value.enabled !== null && typeof value.enabled !== 'boolean') {
+        throw new Error(`${field}.enabled must be a boolean or null`);
+    }
+    if (value.name !== undefined && value.name !== null && typeof value.name !== 'string') {
+        throw new Error(`${field}.name must be a string or null`);
+    }
+    if (value.imageIn !== undefined && value.imageIn !== null && typeof value.imageIn !== 'boolean') {
+        throw new Error(`${field}.imageIn must be a boolean or null`);
+    }
+    if (value.manual !== undefined && typeof value.manual !== 'boolean') {
+        throw new Error(`${field}.manual must be a boolean`);
+    }
+    if (typeof value.enabled === 'boolean')
+        result.enabled = value.enabled;
+    if (typeof value.name === 'string')
+        result.name = value.name;
+    if (typeof value.imageIn === 'boolean')
+        result.imageIn = value.imageIn;
+    if (value.manual === true)
+        result.manual = true;
+    return result;
+}
+function serviceConfig(value, field, serviceType) {
+    if (!isRecord(value))
+        throw new Error(`${field} must be an object`);
+    assertFields(value, ['path', 'style', 'models'], field);
+    const result = {};
+    if (value.path !== undefined) {
+        if (typeof value.path !== 'string')
+            throw new Error(`${field}.path must be a string`);
+        if (/^[a-z][a-z\d+.-]*:/iu.test(value.path.trim()) || value.path.trim().startsWith('//') || /[\\\0\r\n?#]/u.test(value.path)) {
+            throw new Error(`${field}.path must be relative`);
+        }
+        result.path = value.path.trim();
+    }
+    if (value.style !== undefined)
+        result.style = nonEmpty(value.style, `${field}.style`);
+    if (value.models !== undefined) {
+        if (!isRecord(value.models))
+            throw new Error(`${field}.models must be an object`);
+        result.models = {};
+        for (const [modelId, override] of Object.entries(value.models)) {
+            if (!modelId.trim() || PROHIBITED_PATH_SEGMENTS.has(modelId))
+                throw new Error(`${field}.models contains an invalid model ID`);
+            const normalized = modelOverride(override, `${field}.models.${modelId}`);
+            const supportsImageInput = ['text', 'claude', 'codex'].includes(serviceType);
+            const imageMembership = !supportsImageInput && normalized.imageIn !== undefined;
+            if (!supportsImageInput)
+                delete normalized.imageIn;
+            if (Object.keys(normalized).length || !Object.keys(override).length || imageMembership)
+                result.models[modelId] = normalized;
+        }
+        if (!Object.keys(result.models).length)
+            delete result.models;
+    }
+    return result;
+}
+function providerConfig(value, field) {
+    if (!isRecord(value))
+        throw new Error(`${field} must be an object`);
+    assertFields(value, ['name', 'common', 'services'], field);
+    if (value.name !== undefined && typeof value.name !== 'string')
+        throw new Error(`${field}.name must be a string`);
+    if (!isRecord(value.common))
+        throw new Error(`${field}.common must be an object`);
+    const common = value.common;
+    assertFields(common, ['apiKey', 'baseUrl', 'headers', 'queryParams'], `${field}.common`);
+    const baseUrl = nonEmpty(common.baseUrl, `${field}.common.baseUrl`);
+    assertProviderEnvironmentSyntax(baseUrl, `${field}.common.baseUrl`);
+    if (!providerEnvironmentVariable(baseUrl) && !validProviderBaseUrl(baseUrl)) {
+        throw new Error(`${field}.common.baseUrl must be a valid http(s) URL`);
+    }
+    const headers = stringMap(common.headers, `${field}.common.headers`);
+    const queryParams = stringMap(common.queryParams, `${field}.common.queryParams`);
+    if (common.apiKey !== undefined && typeof common.apiKey !== 'string')
+        throw new Error(`${field}.common.apiKey must be a string`);
+    if (typeof common.apiKey === 'string')
+        assertProviderEnvironmentSyntax(common.apiKey, `${field}.common.apiKey`);
+    const result = {
+        ...(typeof value.name === 'string' && value.name.trim() ? { name: value.name.trim() } : {}),
+        common: {
+            baseUrl,
+            ...(typeof common.apiKey === 'string' ? { apiKey: common.apiKey } : {}),
+            ...(headers ? { headers } : {}),
+            ...(queryParams ? { queryParams } : {}),
+        },
+    };
+    if (value.services !== undefined) {
+        if (!isRecord(value.services))
+            throw new Error(`${field}.services must be an object`);
+        result.services = {};
+        for (const [sourceType, service] of Object.entries(value.services)) {
+            assertSafeRegistrySegment(sourceType, `${field}.services service type`);
+            if (sourceType === 'auxiliary')
+                throw new Error(`${field}.services.auxiliary is a purpose alias; configure services.text`);
+            // EC Agent uses the text service's image-input capability settings.
+            const capabilityType = sourceType === 'ecagent' ? 'text' : sourceType;
+            result.services[sourceType] = serviceConfig(service, `${field}.services.${sourceType}`, capabilityType);
+            const fixedStyle = Object.hasOwn(FIXED_STYLES, sourceType) ? FIXED_STYLES[sourceType] : undefined;
+            if (fixedStyle && result.services[sourceType].style && result.services[sourceType].style !== fixedStyle) {
+                throw new Error(`${field}.services.${sourceType} must use style ${fixedStyle}`);
+            }
+        }
+    }
+    return result;
+}
+export function validateProvidersFile(value) {
+    if (!isRecord(value))
+        throw new Error('providers.json must be an object');
+    assertFields(value, ['$schema_version', 'nextId', 'providers'], 'providers.json');
+    if (value.$schema_version !== undefined && (!Number.isInteger(value.$schema_version) || Number(value.$schema_version) < 1)) {
+        throw new Error('providers.json.$schema_version must be a positive integer');
+    }
+    if (value.nextId !== undefined && (!Number.isSafeInteger(value.nextId) || Number(value.nextId) < 1)) {
+        throw new Error('providers.json.nextId must be a positive safe integer');
+    }
+    if (!isRecord(value.providers))
+        throw new Error('providers.json.providers must be an object');
+    const providers = {};
+    for (const [providerId, provider] of Object.entries(value.providers)) {
+        if (!providerId.trim())
+            throw new Error('provider id cannot be empty');
+        assertSafeRegistrySegment(providerId, 'provider id');
+        providers[providerId] = providerConfig(provider, `providers.${providerId}`);
+    }
+    return {
+        ...(typeof value.$schema_version === 'number' ? { $schema_version: value.$schema_version } : {}),
+        ...(typeof value.nextId === 'number' ? { nextId: value.nextId } : {}),
+        providers,
+    };
+}
+export function resolveProviderService(providerId, serviceType, config) {
+    assertSafeRegistrySegment(providerId, 'provider id');
+    assertSafeRegistrySegment(serviceType, 'service type');
+    const providers = config.providers;
+    const provider = Object.hasOwn(providers, providerId) ? providers[providerId] : undefined;
+    if (!provider)
+        throw new Error(`Provider not found: ${providerId}`);
+    const service = provider.services && Object.hasOwn(provider.services, serviceType) ? provider.services[serviceType] : undefined;
+    if (!service)
+        throw new Error(`Provider ${providerId} has no service: ${serviceType}`);
+    const fixedStyle = Object.hasOwn(FIXED_STYLES, serviceType) ? FIXED_STYLES[serviceType] : undefined;
+    const style = fixedStyle || service.style || 'openai-compatible';
+    if (fixedStyle && service.style && service.style !== fixedStyle) {
+        throw new Error(`Provider ${providerId} service ${serviceType} must use style ${fixedStyle}`);
+    }
+    const resolvedBaseUrl = resolveProviderEnvironmentValue(providerId, 'baseUrl', provider.common.baseUrl);
+    if (!validProviderBaseUrl(resolvedBaseUrl)) {
+        throw new Error(`Provider ${providerId} common.baseUrl must resolve to a valid http(s) URL`);
+    }
+    const base = resolvedBaseUrl.endsWith('/') ? resolvedBaseUrl : `${resolvedBaseUrl}/`;
+    const parsed = new URL(service.path || '.', base);
+    if (parsed.origin !== new URL(base).origin)
+        throw new Error(`Provider ${providerId} path must stay on the common origin`);
+    const finalUrl = parsed.toString().replace(/\/+$/u, '');
+    const catalogPath = new URL(finalUrl).pathname.replace(/\/+$/u, '');
+    const apiKey = provider.common.apiKey === undefined
+        ? undefined
+        : resolveProviderEnvironmentValue(providerId, 'apiKey', provider.common.apiKey);
+    return {
+        providerId,
+        serviceType,
+        style,
+        baseUrl: finalUrl,
+        catalogPath,
+        apiKey,
+        headers: provider.common.headers,
+        queryParams: provider.common.queryParams,
+        modelOverrides: service.models ?? {},
+    };
+}
+export function resolveProviderServiceForBaseagent(providerId, baseagent, preferredServiceType, config) {
+    const serviceType = resolveProviderServiceTypeForBaseagent(baseagent, preferredServiceType);
+    return resolveProviderService(providerId, serviceType, config);
+}
+export function resolveProviderModelOverrides(providerId, serviceType, config) {
+    assertSafeRegistrySegment(providerId, 'provider id');
+    assertSafeRegistrySegment(serviceType, 'service type');
+    const provider = Object.hasOwn(config.providers, providerId) ? config.providers[providerId] : undefined;
+    if (!provider)
+        throw new Error(`Provider not found: ${providerId}`);
+    const service = provider.services && Object.hasOwn(provider.services, serviceType) ? provider.services[serviceType] : undefined;
+    if (!service)
+        throw new Error(`Provider ${providerId} has no service: ${serviceType}`);
+    const fixedStyle = Object.hasOwn(FIXED_STYLES, serviceType) ? FIXED_STYLES[serviceType] : undefined;
+    if (fixedStyle && service.style && service.style !== fixedStyle) {
+        throw new Error(`Provider ${providerId} service ${serviceType} must use style ${fixedStyle}`);
+    }
+    return service.models ?? {};
+}
+export function providerIsConfigured(config) {
+    return config?.provider !== undefined;
+}
+export function resolveServiceSelection(selections, serviceType, resolve) {
+    const selection = selections?.[serviceType];
+    if (!selection)
+        return undefined;
+    const providerId = nonEmpty(selection.provider, `Services.${serviceType}.provider`);
+    const model = nonEmpty(selection.model, `Services.${serviceType}.model`);
+    const resolved = resolve(providerId, providerServiceTypeForPurpose(serviceType));
+    if (resolved.modelOverrides[model]?.enabled === false)
+        throw new Error(`Model ${model} is disabled for provider ${providerId}`);
+    return { ...resolved, model, effort: selection.effort };
+}
+export function assertProviderSelectionWrite(next, previous, inherited, resolveModelOverrides) {
+    for (const [baseagent, block] of Object.entries(next.baseagents ?? {})) {
+        if (!isRecord(block))
+            continue;
+        const before = previous.baseagents?.[baseagent] ?? {};
+        const selection = { ...inherited.baseagents?.[baseagent], ...block };
+        for (const field of ['apiKey', 'baseUrl', 'headers', 'queryParams']) {
+            if (block[field] !== undefined && !isDeepStrictEqual(block[field], before[field])) {
+                throw new Error(`baseagents.${baseagent}.${field} is read-only legacy configuration; configure connection parameters in providers.json`);
+            }
+        }
+        const changed = !isDeepStrictEqual(block.provider, before.provider)
+            || !isDeepStrictEqual(block.providerServiceType, before.providerServiceType)
+            || !isDeepStrictEqual(block.model, before.model) || !isDeepStrictEqual(block.fallback, before.fallback);
+        if (changed) {
+            const serviceType = resolveProviderServiceTypeForBaseagent(baseagent, selection.providerServiceType);
+            if (selection.provider !== undefined) {
+                const modelOverrides = resolveModelOverrides(selection.provider, serviceType);
+                if (selection.model && modelOverrides[selection.model]?.enabled === false) {
+                    throw new Error(`Model ${selection.model} is disabled for provider ${selection.provider}`);
+                }
+            }
+            for (const candidate of Array.isArray(selection.fallback) ? selection.fallback : []) {
+                const providerId = candidate?.provider ?? selection.provider;
+                if (!providerId || typeof candidate?.model !== 'string')
+                    continue;
+                const modelOverrides = resolveModelOverrides(providerId, serviceType);
+                if (modelOverrides[candidate.model]?.enabled === false) {
+                    throw new Error(`Model ${candidate.model} is disabled for provider ${providerId}`);
+                }
+            }
+        }
+    }
+    for (const field of ['apikey', 'base_url', 'headers', 'queryParams']) {
+        const value = next.decision_model?.[field];
+        if (value !== undefined && !isDeepStrictEqual(value, previous.decision_model?.[field])) {
+            throw new Error(`decision_model.${field} is read-only legacy configuration; configure Services.decision and providers.json`);
+        }
+    }
+    if (next.Services !== undefined && !isRecord(next.Services))
+        throw new Error('Services must be an object');
+    for (const [serviceType, selection] of Object.entries(next.Services ?? {})) {
+        assertSafeRegistrySegment(serviceType, 'service type');
+        if (!isRecord(selection))
+            throw new Error(`Services.${serviceType} must be an object`);
+        assertFields(selection, ['provider', 'model', 'effort', 'fallback'], `Services.${serviceType}`);
+        if (isDeepStrictEqual(selection, previous.Services?.[serviceType]))
+            continue;
+        const effective = { ...inherited.Services?.[serviceType], ...selection };
+        if (!Object.keys(effective).length)
+            continue;
+        const providerId = nonEmpty(effective.provider, `Services.${serviceType}.provider`);
+        nonEmpty(effective.model, `Services.${serviceType}.model`);
+        const modelOverrides = resolveModelOverrides(providerId, providerServiceTypeForPurpose(serviceType));
+        if (modelOverrides[effective.model]?.enabled === false) {
+            throw new Error(`Model ${effective.model} is disabled for provider ${providerId}`);
+        }
+        for (const candidate of Array.isArray(effective.fallback) ? effective.fallback : []) {
+            const providerId = candidate?.provider ?? effective.provider;
+            if (!providerId || typeof candidate?.model !== 'string')
+                continue;
+            const candidateOverrides = resolveModelOverrides(providerId, providerServiceTypeForPurpose(serviceType));
+            if (candidateOverrides[candidate.model]?.enabled === false) {
+                throw new Error(`Model ${candidate.model} is disabled for provider ${providerId}`);
+            }
+        }
+    }
+}

package/dist/config/providers-import.js

@@ -0,0 +1,74 @@
+import { DEFAULT_ECAGENT_BASE_URL, resolveAnthropicConfig, resolveEcagentConfig, resolveGoogleConfig, resolveOpenaiConfig, } from '../agents/baseagent.js';
+import { ConfigTarget, read } from './config-manager.js';
+import { readProvidersFile } from './providers.js';
+import { providerNameFromBaseUrlIfStatic, providerServiceTypeForBaseagent, resolveProviderServiceForBaseagent, validateProvidersFile } from './providers-config.js';
+const IMPORTABLE_BASEAGENTS = ['claude', 'codex', 'gemini', 'ecagent'];
+function resolveConnection(baseagent, config, projectPath) {
+    if (baseagent === 'claude')
+        return resolveAnthropicConfig(config, config.agents?.claude, { projectPath });
+    if (baseagent === 'codex')
+        return resolveOpenaiConfig(config, config.agents?.codex);
+    if (baseagent === 'ecagent')
+        return resolveEcagentConfig(config, config.agents?.ecagent);
+    return {
+        ...resolveGoogleConfig(config, { ...config.agents?.gemini, cliPath: config.agents?.gemini?.cliPath || 'gemini' }),
+        baseUrl: process.env.GOOGLE_GEMINI_BASE_URL || 'https://generativelanguage.googleapis.com/v1beta',
+    };
+}
+export function providerFromBaseagent(baseagent) {
+    if (!IMPORTABLE_BASEAGENTS.includes(baseagent))
+        throw new Error('Invalid baseagent');
+    const source = read(ConfigTarget.Defaults, undefined, { cache: false, expand: true });
+    const selected = baseagent;
+    const block = source?.baseagents?.[selected];
+    if (block?.provider !== undefined) {
+        const providers = readProvidersFile().providers;
+        const provider = Object.hasOwn(providers, block.provider) ? providers[block.provider] : undefined;
+        if (!provider)
+            throw new Error('Source baseagent references a missing Provider');
+        const resolved = resolveProviderServiceForBaseagent(block.provider, selected, block.providerServiceType, { providers });
+        const serviceType = resolved.serviceType;
+        const service = provider.services?.[serviceType];
+        if (!service)
+            throw new Error('Source Provider does not support the selected baseagent');
+        if (!provider.common.apiKey?.trim())
+            throw new Error('Source baseagent has no API key / token');
+        return structuredClone({ name: provider.name || providerNameFromBaseUrlIfStatic(provider.common.baseUrl), common: provider.common, services: { [serviceType]: service } });
+    }
+    const serviceType = providerServiceTypeForBaseagent(selected);
+    const config = { agents: source?.baseagents };
+    const connection = resolveConnection(selected, config, source?.projects?.defaultPath);
+    if (connection.useVertex)
+        throw new Error('Vertex AI settings cannot be imported as a Gemini API-key Provider');
+    if (!connection.apiKey?.trim() || /your-|placeholder|<redacted>/u.test(connection.apiKey))
+        throw new Error('Source baseagent has no valid API key / token');
+    const defaultBaseUrls = {
+        claude: 'https://api.anthropic.com',
+        codex: 'https://api.openai.com/v1',
+        gemini: 'https://generativelanguage.googleapis.com/v1beta',
+        ecagent: DEFAULT_ECAGENT_BASE_URL,
+    };
+    const provider = {
+        common: {
+            baseUrl: connection.baseUrl || defaultBaseUrls[selected],
+            ...(connection.apiKey ? { apiKey: connection.apiKey } : {}),
+            ...(connection.headers ? { headers: connection.headers } : {}),
+            ...(connection.queryParams ? { queryParams: connection.queryParams } : {}),
+        },
+        services: { [serviceType]: { path: '' } },
+    };
+    const normalized = validateProvidersFile({ providers: { imported: provider } }).providers.imported;
+    normalized.name ||= providerNameFromBaseUrlIfStatic(normalized.common.baseUrl);
+    return normalized;
+}
+export function listBaseagentImportSources() {
+    return IMPORTABLE_BASEAGENTS.flatMap(baseagent => {
+        try {
+            const provider = providerFromBaseagent(baseagent);
+            return [{ baseagent, name: provider.name || baseagent, baseUrl: provider.common.baseUrl }];
+        }
+        catch {
+            return [];
+        }
+    });
+}