evolcore 0.0.20 → 0.0.21

package/dist/config/config-manager.js

@@ -29,6 +29,7 @@ import { clearRoleStoreCache, isRoleName } from './role-store.js';
 import { writeRoleDefinition, writeRoleRegistry } from './role-service.js';
 import { mutateContactBookTransactionSync } from './contact-book-store.js';
 import { DAEMON_SCHEMA_NAME } from '../product.js';
+import { normalizeDaemonServices } from './daemon-services.js';
 // AUN gateway discovery belongs to fastaun. Keep the retired gatewayUrl
 // compatibility handling beside the rest of the configuration read/write
 // policy so all config callers share one implementation.
@@ -595,11 +596,13 @@ export function read(target, sel, opts = {}) {
     raw = stripLegacyAunGatewayConfig(raw, file, message => configWarn(message));
     // schema 版本迁移（read 时若 $schema_version < current）
     const migrated = migrateIfNeeded(target, raw, file);
-    const normalized = target === ConfigTarget.Agent
-        ? normalizeAgentConfigForRead(migrated, sel?.self)
-        : target === ConfigTarget.Relation
-            ? foldLegacyProactiveBlock(migrated)
-            : migrated;
+    const normalized = target === ConfigTarget.Process
+        ? normalizeProcessConfigCompat(normalizeDaemonServices(migrated))
+        : target === ConfigTarget.Agent
+            ? normalizeAgentConfigForRead(migrated, sel?.self)
+            : target === ConfigTarget.Relation
+                ? foldLegacyProactiveBlock(migrated)
+                : migrated;
     // Agent read compatibility may move the legacy top-level `agents` block to
     // `baseagents`, so canonicalize effort after that structural migration.
     const canonicalized = normalizeBaseagentEffortCompat(normalized);
@@ -680,12 +683,11 @@ function normalizeAgentConfigForWrite(value) {
     if (mutable.aid && !isValidAid(mutable.aid)) {
         throw new ConfigError('VALIDATION_ERROR', `Invalid aid "${mutable.aid}" (must be a valid multi-level domain like mybot.agentid.pub)`);
     }
-    // 规范化 projects 字段：只保留 rootPath 和 defaultPath
+    // 规范化 projects 字段：只保留唯一公开项目路径 defaultPath。
+    // defaults.projects.rootPath 已废弃，不能继续成为有效运行时参数。
     if (mutable.projects && typeof mutable.projects === 'object') {
         const projects = mutable.projects;
         const normalized = {};
-        if (typeof projects.rootPath === 'string')
-            normalized.rootPath = projects.rootPath;
         if (typeof projects.defaultPath === 'string')
             normalized.defaultPath = projects.defaultPath;
         if (Object.keys(normalized).length > 0) {
@@ -698,19 +700,58 @@ function normalizeAgentConfigForWrite(value) {
     return mutable;
 }
 function normalizeProcessConfigForWrite(value) {
-    const configuredAidDomain = value.aun?.defaultAidDomain;
+    let normalized;
+    try {
+        normalized = normalizeProcessConfigCompat(normalizeDaemonServices(value));
+    }
+    catch (error) {
+        throw new ConfigError('DAEMON_SERVICES_MIGRATION_REQUIRED', error instanceof Error ? error.message : String(error));
+    }
+    const configuredAidDomain = normalized.aun?.defaultAidDomain;
     if (configuredAidDomain === undefined)
-        return value;
+        return normalized;
     try {
         return {
-            ...value,
-            aun: { ...value.aun, defaultAidDomain: normalizeAidDomain(configuredAidDomain, 'aun.defaultAidDomain') },
+            ...normalized,
+            aun: { ...normalized.aun, defaultAidDomain: normalizeAidDomain(configuredAidDomain, 'aun.defaultAidDomain') },
         };
     }
     catch (error) {
         throw new ConfigError('VALIDATION_ERROR', error instanceof Error ? error.message : String(error));
     }
 }
+/**
+ * Normalize renamed process-level settings while keeping old daemon.json files
+ * readable after an upgrade. New values take precedence when both keys exist.
+ */
+export function normalizeProcessConfigCompat(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const idleMonitor = value.idleMonitor;
+    const debug = value.debug;
+    let changed = false;
+    let normalized = value;
+    if (idleMonitor && typeof idleMonitor === 'object' && !Array.isArray(idleMonitor)) {
+        const nextIdleMonitor = { ...idleMonitor };
+        if (nextIdleMonitor.apiRetryTimeout === undefined && nextIdleMonitor.retryAttemptTimeout !== undefined) {
+            nextIdleMonitor.apiRetryTimeout = nextIdleMonitor.retryAttemptTimeout;
+            changed = true;
+        }
+        if (Object.prototype.hasOwnProperty.call(nextIdleMonitor, 'retryAttemptTimeout')) {
+            delete nextIdleMonitor.retryAttemptTimeout;
+            changed = true;
+        }
+        if (changed)
+            normalized = { ...normalized, idleMonitor: nextIdleMonitor };
+    }
+    if (debug && typeof debug === 'object' && !Array.isArray(debug)
+        && Object.prototype.hasOwnProperty.call(debug, 'flusherDiag')) {
+        const nextDebug = { ...debug };
+        delete nextDebug.flusherDiag;
+        normalized = { ...normalized, debug: nextDebug };
+    }
+    return normalized;
+}
 function normalizeRelationConfigForWrite(value) {
     const mutable = normalizeBaseagentEffortCompat({ ...value });
     normalizeShowActivitiesCompat(mutable);
@@ -985,7 +1026,11 @@ function ensureSchemaVersion(value, version) {
 }
 function validateOrThrow(schema, value, target) {
     const ok = schema.validate(value);
-    const scopeErrors = [...validateProcessOnlyFields(target, value), ...validateProcessAidDomain(target, value)];
+    const scopeErrors = [
+        ...validateProcessOnlyFields(target, value),
+        ...validateProcessAidDomain(target, value),
+        ...validateProcessServiceNames(target, value),
+    ];
     if (!ok || scopeErrors.length > 0) {
         const errs = [
             ...scopeErrors,
@@ -1026,6 +1071,24 @@ function validateProcessAidDomain(target, value) {
         return [`/aun/defaultAidDomain ${error instanceof Error ? error.message : String(error)}`];
     }
 }
+function validateProcessServiceNames(target, value) {
+    if (target !== ConfigTarget.Process || !value || typeof value !== 'object')
+        return [];
+    const services = value.services;
+    if (!Array.isArray(services))
+        return [];
+    const seen = new Set();
+    const errors = [];
+    services.forEach((service, index) => {
+        if (!service || typeof service !== 'object' || typeof service.name !== 'string')
+            return;
+        if (seen.has(service.name))
+            errors.push(`/services/${index}/name duplicates service name ${JSON.stringify(service.name)}`);
+        else
+            seen.add(service.name);
+    });
+    return errors;
+}
 /**
  * responseModeParams 桶专项校验。
  *
@@ -1076,8 +1139,28 @@ export function validateConfig(target, value) {
         ? loadSchema('contact-book', 2)
         : loadSchema(TARGET_SCHEMA[target]);
     const withVer = ensureSchemaVersion(value, schema.version);
-    const ok = schema.validate(withVer);
-    const errors = [...validateProcessOnlyFields(target, withVer), ...validateProcessAidDomain(target, withVer)];
+    let normalized = withVer;
+    try {
+        if (target === ConfigTarget.Process)
+            normalized = normalizeProcessConfigCompat(normalizeDaemonServices(withVer));
+    }
+    catch (error) {
+        return [error instanceof Error ? error.message : String(error)];
+    }
+    const ok = schema.validate(normalized);
+    const errors = [
+        ...validateProcessOnlyFields(target, normalized),
+        ...validateProcessAidDomain(target, normalized),
+        ...validateProcessServiceNames(target, normalized),
+    ];
+    if (target === ConfigTarget.Defaults || target === ConfigTarget.Agent || target === ConfigTarget.Relation) {
+        try {
+            validateResponseModeParams(normalized?.responseModeParams, target);
+        }
+        catch (error) {
+            errors.push(error instanceof ConfigError ? error.message : String(error));
+        }
+    }
     if (ok && errors.length === 0)
         return [];
     return [
@@ -1097,7 +1180,15 @@ export function validateConfigFile(target, sel) {
         return { exists: false, errors: [] };
     // Persisted pre-removal files remain readable: validate the same sanitized
     // view used by runtime reads, while new writes are still rejected by write().
-    const sanitized = stripLegacyAunGatewayConfig(value, file, message => configWarn(message));
+    let sanitized;
+    try {
+        sanitized = target === ConfigTarget.Process
+            ? normalizeDaemonServices(stripLegacyAunGatewayConfig(value, file, message => configWarn(message)))
+            : stripLegacyAunGatewayConfig(value, file, message => configWarn(message));
+    }
+    catch (error) {
+        return { exists: true, errors: [error instanceof Error ? error.message : String(error)] };
+    }
     return { exists: true, errors: validateConfig(target, sanitized) };
 }
 function fileCacheAvailable() {
@@ -1159,13 +1250,40 @@ export function resolveAgentConfig(sel, opts = {}) {
     const agentConfig = sel.self ? read(ConfigTarget.Agent, sel, opts) : null;
     const relationConfig = (sel.self && sel.peerKey) ? read(ConfigTarget.Relation, sel, opts) : null;
     const layers = [
-        stripStaticOwnerField(read(ConfigTarget.Defaults, undefined, opts)),
+        stripStaticOwnerField(normalizeDefaultsBehaviorCompat(read(ConfigTarget.Defaults, undefined, opts))),
         agentConfig,
         stripRelationRoleData(stripStaticOwnerField(relationConfig)),
     ];
     const merged = mergeLayers(layers, fields);
     return merged;
 }
+/**
+ * defaults.schema keeps the historical `config` object as the process-wide
+ * response behavior compatibility surface. Make those values participate in
+ * the normal agent/relation merge chain without leaking the compatibility
+ * container itself into EffectiveAgentConfig.
+ *
+ * Explicit canonical fields (if a future schema adds them) always win. A
+ * single default chat mode applies to the three peer categories because this
+ * compatibility field predates the per-category `chatmode` dictionary.
+ */
+export function normalizeDefaultsBehaviorCompat(defaults) {
+    if (!defaults || !defaults.config || typeof defaults.config !== 'object' || Array.isArray(defaults.config))
+        return defaults;
+    const { config, ...rest } = defaults;
+    const normalized = { ...rest };
+    const chatMode = config.chatMode;
+    if (!normalized.chatmode && (chatMode === 'interactive' || chatMode === 'proactive')) {
+        normalized.chatmode = { private: chatMode, group: chatMode, nothuman: chatMode };
+    }
+    if (normalized.mentionMode === undefined && (config.mentionMode === 'disabled' || config.mentionMode === 'mention-only')) {
+        normalized.mentionMode = config.mentionMode;
+    }
+    if (normalized.show_activities === undefined && ['all', 'text', 'none'].includes(config.show_activities)) {
+        normalized.show_activities = config.show_activities;
+    }
+    return normalized;
+}
 function stripStaticOwnerField(config) {
     if (!config)
         return config;

package/dist/config/contact-operation-service.js

@@ -4,7 +4,7 @@ import { isExplicitGroupId } from '../aun/group-identity.js';
 import { agentConfig } from '../paths.js';
 import { getContactSnapshot, resolveContactView } from './contact-book.js';
 import { ContactMutationError } from './contact-book-store.js';
-import { mutateContactWithOperation } from './contact-request-service.js';
+import { addContact, mutateContactWithOperation } from './contact-request-service.js';
 export function resolveContactCommand(argv) {
     const args = argv[0] === 'contact' ? argv.slice(1) : [...argv];
     const selfAid = String(argValue(args, '--self') || '').trim();
@@ -39,6 +39,21 @@ export function resolveContactCommand(argv) {
             },
         };
     }
+    if (command === 'add') {
+        if (!isValidAid(subcommand || '') || isExplicitGroupId(subcommand || '')) {
+            return invalid('INVALID_AID', 'primaryId must be a valid individual AID');
+        }
+        return {
+            ok: true,
+            command: {
+                kind: 'add',
+                operationId: 'contact.add',
+                selfAid,
+                primaryId: subcommand,
+                canonicalArgv: canonicalArgv(argv),
+            },
+        };
+    }
     return invalid('UNKNOWN_COMMAND', `Unknown contact command: ${positional.join(' ')}`);
 }
 export async function executeResolvedContactCommand(command, actor = 'local-cli') {
@@ -81,6 +96,22 @@ export async function executeResolvedContactCommand(command, actor = 'local-cli'
                 contactRevision: result.contactRevision,
             };
         }
+        if (command.kind === 'add') {
+            const result = await addContact({
+                selfAid: command.selfAid,
+                primaryId: command.primaryId,
+                actorId: actor,
+            });
+            return {
+                ok: true,
+                operation: 'add',
+                selfAid: command.selfAid,
+                primaryId: command.primaryId,
+                status: 'active',
+                changed: result.changed,
+                contactRevision: result.contactRevision,
+            };
+        }
         return { ok: false, code: 'CONTACT_OPERATION_FAILED', error: 'Unsupported contact operation' };
     }
     catch (error) {

package/dist/config/contact-request-service.js

@@ -38,6 +38,50 @@ export async function mutateContactWithOperation(input) {
     const { value: _value, ...mutationResult } = result;
     return mutationResult;
 }
+/**
+ * Add a canonical AUN contact as active through the Contact Book transaction.
+ * Existing pending/declined entries are intentionally promoted here, while a
+ * blocked entry remains a hard stop and must be explicitly unblocked first.
+ */
+export async function addContact(input) {
+    const primaryId = String(input.primaryId || '').trim();
+    if (!isValidAid(primaryId)) {
+        throw new ContactMutationError('INVALID_AID', `Invalid contact AID: ${primaryId}`);
+    }
+    const at = new Date(input.now ?? Date.now()).toISOString();
+    const logFile = agentContactOperations(input.selfAid);
+    const result = await mutateContactBookPrepared(input.selfAid, ({ contact, contactRevision }) => {
+        if (input.expectedContactRevision !== undefined && input.expectedContactRevision !== contactRevision) {
+            throw new ContactMutationError('CONFLICT', 'Contact book changed since it was read', {
+                expectedContactRevision: input.expectedContactRevision,
+                contactRevision,
+            });
+        }
+        if (contact.contacts[primaryId]?.status === 'blocked') {
+            throw new ContactMutationError('CONTACT_BLOCKED', `Contact is blocked: ${primaryId}`);
+        }
+        const mutations = [
+            { type: 'set-status', primaryId, status: 'active' },
+        ];
+        if (input.displayName !== undefined) {
+            mutations.push({ type: 'set-display-name', primaryId, displayName: input.displayName });
+        }
+        return {
+            mutation: mutations.length === 1 ? mutations[0] : { type: 'batch', mutations },
+            actor: input.actorId,
+            value: undefined,
+            beforeCommit: ({ contactRevision: nextRevision }) => operationLogChange(logFile, [operationRecord({
+                    at,
+                    op: 'manual-add',
+                    primaryId,
+                    actorId: input.actorId,
+                    contactRevision: nextRevision,
+                })]),
+        };
+    });
+    const { value: _value, ...mutationResult } = result;
+    return mutationResult;
+}
 export async function submitContactRequest(input) {
     const applicantAid = String(input.applicantAid || '').trim();
     const owners = listAgentOwners(input.selfAid);

package/dist/config/daemon-services.js

@@ -0,0 +1,186 @@
+const SERVICE_TYPES = new Set(['http', 'websocket', 'ssh']);
+const SERVICE_VISIBILITIES = new Set(['public', 'private', 'aun-auth']);
+export const DEFAULT_ECWEB_PORT = 42705;
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Convert the former `ecweb` + `serviceProxy` process configuration into the
+ * service-instance model. The function is intentionally idempotent and does
+ * not mutate its input.
+ */
+export function normalizeDaemonServices(raw, warn) {
+    if (!isRecord(raw))
+        return raw;
+    const next = { ...raw };
+    const hasLegacyEcweb = Object.prototype.hasOwnProperty.call(raw, 'ecweb');
+    const hasLegacyProxy = Object.prototype.hasOwnProperty.call(raw, 'serviceProxy');
+    const hasCanonicalServices = Object.prototype.hasOwnProperty.call(raw, 'services');
+    const services = [];
+    if (hasCanonicalServices) {
+        if (!Array.isArray(raw.services)) {
+            throw new Error('daemon.json.services must be an array');
+        }
+        for (const [index, value] of raw.services.entries()) {
+            if (!isRecord(value)) {
+                throw new Error(`daemon.json.services[${index}] must be an object`);
+            }
+            if (typeof value.name !== 'string' || value.name.trim() === '') {
+                throw new Error(`daemon.json.services[${index}].name must be a non-empty string`);
+            }
+            // Preserve the canonical object for schema validation. In particular,
+            // do not trim/drop fields here, otherwise malformed new-format config
+            // could be silently rewritten into a different valid-looking shape.
+            services.push({ ...value });
+        }
+    }
+    if (hasLegacyEcweb && !isRecord(raw.ecweb)) {
+        throw new Error('daemon.json.ecweb must be an object before it can be migrated');
+    }
+    if (hasLegacyProxy && !isRecord(raw.serviceProxy)) {
+        throw new Error('daemon.json.serviceProxy must be an object before it can be migrated');
+    }
+    const legacyEcweb = hasLegacyEcweb ? raw.ecweb : undefined;
+    const legacyProxy = hasLegacyProxy ? raw.serviceProxy : undefined;
+    if (legacyEcweb?.enabled !== undefined && typeof legacyEcweb.enabled !== 'boolean') {
+        throw new Error('daemon.json.ecweb.enabled must be a boolean before it can be migrated');
+    }
+    if (legacyEcweb?.port !== undefined && typeof legacyEcweb.port !== 'number') {
+        throw new Error('daemon.json.ecweb.port must be a number before it can be migrated');
+    }
+    if (legacyProxy?.enabled !== undefined && typeof legacyProxy.enabled !== 'boolean') {
+        throw new Error('daemon.json.serviceProxy.enabled must be a boolean before it can be migrated');
+    }
+    const legacyProxyServices = [];
+    if (legacyProxy?.services !== undefined) {
+        if (!Array.isArray(legacyProxy.services)) {
+            throw new Error('daemon.json.serviceProxy.services must be an array before it can be migrated');
+        }
+        for (const [index, value] of legacyProxy.services.entries()) {
+            if (!isRecord(value)) {
+                throw new Error(`daemon.json.serviceProxy.services[${index}] cannot be represented by source="instance"`);
+            }
+            if (value.enabled !== undefined && typeof value.enabled !== 'boolean') {
+                throw new Error(`daemon.json.serviceProxy.services[${index}].enabled must be a boolean before it can be migrated`);
+            }
+            if (value.visibility !== undefined && typeof value.visibility !== 'string') {
+                throw new Error(`daemon.json.serviceProxy.services[${index}].visibility must be a string before it can be migrated`);
+            }
+            legacyProxyServices.push(value);
+        }
+    }
+    const legacyEcwebProxy = legacyProxyServices.find((value) => value.name === 'ecweb');
+    const ecwebIndex = services.findIndex((service) => service.name === 'ecweb');
+    // Convert the former flat serviceProxy entries into canonical services[].
+    // Keep every service rather than silently dropping non-ecweb entries.
+    for (const legacy of legacyProxyServices) {
+        const name = typeof legacy.name === 'string' ? legacy.name : '';
+        if (!name || name === 'ecweb')
+            continue;
+        if (services.some((service) => service.name === name))
+            continue;
+        const source = legacy.source === 'ecweb'
+            ? 'instance'
+            : legacy.source === 'instance'
+                ? 'instance'
+                : typeof legacy.endpoint === 'string' && legacy.endpoint.trim()
+                    ? 'static'
+                    : 'static';
+        const proxy = {
+            enabled: legacyProxy?.enabled === true && legacy.enabled !== false,
+            source,
+            ...(typeof legacy.endpoint === 'string' ? { endpoint: legacy.endpoint } : {}),
+            ...(typeof legacy.serviceType === 'string' && SERVICE_TYPES.has(legacy.serviceType)
+                ? { serviceType: legacy.serviceType } : {}),
+            ...(typeof legacy.visibility === 'string' ? { visibility: legacy.visibility } : {}),
+            ...(isRecord(legacy.metadata) ? { metadata: { ...legacy.metadata } } : {}),
+        };
+        services.push({ name, enabled: true, proxy });
+    }
+    if (legacyEcweb || legacyEcwebProxy) {
+        const service = ecwebIndex >= 0
+            ? services[ecwebIndex]
+            : {
+                name: 'ecweb',
+                // The old ECWeb lifecycle switch and Service Proxy switch were
+                // independent. Preserve that distinction during migration: a
+                // proxy-only config must not start managing the local process.
+                enabled: legacyEcweb?.enabled === true,
+            };
+        if (legacyEcweb) {
+            if (service.enabled === undefined && typeof legacyEcweb.enabled === 'boolean')
+                service.enabled = legacyEcweb.enabled;
+            if (service.port === undefined && typeof legacyEcweb.port === 'number')
+                service.port = legacyEcweb.port;
+        }
+        if (service.proxy !== undefined && !isRecord(service.proxy)) {
+            throw new Error('daemon.json.services[ecweb].proxy must be an object before legacy proxy settings can be migrated');
+        }
+        const proxy = { ...(service.proxy ?? {}) };
+        if (legacyEcwebProxy) {
+            if (proxy.enabled === undefined) {
+                proxy.enabled = legacyProxy?.enabled === true && legacyEcwebProxy.enabled !== false;
+            }
+            if (proxy.source === undefined) {
+                proxy.source = legacyEcwebProxy.source === 'static'
+                    || (typeof legacyEcwebProxy.endpoint === 'string' && legacyEcwebProxy.endpoint.trim())
+                    ? 'static'
+                    : 'instance';
+            }
+            if (proxy.endpoint === undefined && typeof legacyEcwebProxy.endpoint === 'string')
+                proxy.endpoint = legacyEcwebProxy.endpoint;
+            if (proxy.serviceType === undefined && typeof legacyEcwebProxy.serviceType === 'string'
+                && SERVICE_TYPES.has(legacyEcwebProxy.serviceType)) {
+                proxy.serviceType = legacyEcwebProxy.serviceType;
+            }
+            if (proxy.visibility === undefined && typeof legacyEcwebProxy.visibility === 'string') {
+                proxy.visibility = legacyEcwebProxy.visibility;
+            }
+            if (proxy.metadata === undefined && isRecord(legacyEcwebProxy.metadata)) {
+                proxy.metadata = { ...legacyEcwebProxy.metadata };
+            }
+            if (proxy.enabled === true && proxy.visibility === undefined)
+                proxy.visibility = 'private';
+        }
+        if (Object.keys(proxy).length > 0)
+            service.proxy = proxy;
+        if (ecwebIndex < 0)
+            services.push(service);
+    }
+    if (hasCanonicalServices || services.length > 0)
+        next.services = services;
+    if (hasLegacyEcweb || hasLegacyProxy) {
+        warn?.('[config] daemon.json: ecweb/serviceProxy 已归一化为 services[]');
+        delete next.ecweb;
+        delete next.serviceProxy;
+    }
+    return next;
+}
+export function findService(services, name) {
+    return (services ?? []).find((service) => service.name === name);
+}
+export function ecwebService(services) {
+    return findService(services, 'ecweb');
+}
+export function upsertService(services, patch) {
+    const current = services ?? [];
+    const index = current.findIndex((service) => service.name === patch.name);
+    if (index < 0)
+        return [...current, patch];
+    const existing = current[index];
+    const replacement = {
+        ...existing,
+        ...patch,
+        ...(existing.proxy || patch.proxy
+            ? { proxy: { ...(existing.proxy ?? {}), ...(patch.proxy ?? {}) } }
+            : {}),
+    };
+    return current.map((service, serviceIndex) => serviceIndex === index ? replacement : service);
+}
+export function setEcwebEnabled(services, enabled, port = ecwebService(services)?.port ?? DEFAULT_ECWEB_PORT) {
+    return upsertService(services, {
+        name: 'ecweb',
+        enabled,
+        port,
+    });
+}

package/dist/config/gateway-config.js

@@ -17,6 +17,7 @@ import { resolvePaths } from '../paths.js';
 import { saveDefaultsSafe, saveAgent } from '../config-store.js';
 import { resolveAnthropicConfig, resolveEcagentConfig, resolveOpenaiConfig } from '../agents/baseagent.js';
 import { buildModelRequestHeaders } from '../agents/request-identity.js';
+import { appendV1RequestPath } from '../agents/request-identity.js';
 import { resolvePriceRow } from '../stats/billing.js';
 import { ipcQuery } from '../ipc.js';
 import { logger } from '../utils/logger.js';
@@ -541,6 +542,7 @@ function resolveGatewayCreds(scope, type) {
                 baseUrl: r.baseUrl,
                 apiKey: r.apiKey,
                 headers: buildModelRequestHeaders({ baseagent: 'codex', baseUrl: r.baseUrl, agentAid: scope === 'defaults' ? undefined : scope, configuredHeaders: r.headers }),
+                queryParams: r.queryParams,
             };
         }
         else if (type === 'claude') {
@@ -549,6 +551,7 @@ function resolveGatewayCreds(scope, type) {
                 baseUrl: r.baseUrl,
                 apiKey: r.apiKey,
                 headers: buildModelRequestHeaders({ baseagent: 'claude', baseUrl: r.baseUrl, agentAid: scope === 'defaults' ? undefined : scope, configuredHeaders: r.headers }),
+                queryParams: r.queryParams,
             };
         }
         else if (type === 'ecagent') {
@@ -557,6 +560,7 @@ function resolveGatewayCreds(scope, type) {
                 baseUrl: r.baseUrl,
                 apiKey: r.apiKey,
                 headers: buildModelRequestHeaders({ baseagent: 'ecagent', baseUrl: r.baseUrl, agentAid: scope === 'defaults' ? undefined : scope, configuredHeaders: r.headers }),
+                queryParams: r.queryParams,
             };
         }
         return { error: 'gemini 暂不支持 HTTP 探测（CLI 后端）', code: 'NOT_SUPPORTED' };
@@ -574,20 +578,19 @@ export async function gatewayTest(args) {
     const creds = resolveGatewayCreds(scope, type);
     if ('error' in creds)
         return creds;
-    const { baseUrl, apiKey, headers } = creds;
+    const { baseUrl, apiKey, headers, queryParams } = creds;
     if (!baseUrl)
         return { error: '未配置 baseUrl（或为官方占位地址）', code: 'INVALID_ARGS' };
     const start = Date.now();
+    let timer;
     try {
         const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 5000);
-        const base = baseUrl.replace(/\/+$/, '');
-        const modelsUrl = base.endsWith('/v1') ? `${base}/models` : `${base}/v1/models`;
+        timer = setTimeout(() => controller.abort(), 5000);
+        const modelsUrl = appendV1RequestPath(baseUrl, 'models', queryParams);
         const resp = await fetch(modelsUrl, {
             headers: { ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}), ...headers },
             signal: controller.signal,
         });
-        clearTimeout(timer);
         const latency = Date.now() - start;
         if (!resp.ok)
             return { data: { ok: false, latency, error: `HTTP ${resp.status}` } };
@@ -600,6 +603,10 @@ export async function gatewayTest(args) {
     catch (e) {
         return { data: { ok: false, latency: Date.now() - start, error: e?.message || String(e) } };
     }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
 }
 /** 从 model-prices.jsonl 的 PriceRecord 提取展示用价格四元组。 */
 function priceRowToQuad(row) {
@@ -632,19 +639,19 @@ export async function gatewayModels(args) {
     const creds = resolveGatewayCreds(scope, type);
     if ('error' in creds)
         return creds;
-    const { baseUrl, apiKey, headers } = creds;
+    const { baseUrl, apiKey, headers, queryParams } = creds;
     if (!baseUrl)
         return { error: '未配置 baseUrl（或为官方占位地址）', code: 'INVALID_ARGS' };
     let arr = [];
     let usdToCny = 7; // 默认汇率
+    let timer;
     try {
         const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 8000);
-        const resp = await fetch(`${baseUrl.replace(/\/+$/, '')}/v1/models`, {
+        timer = setTimeout(() => controller.abort(), 8000);
+        const resp = await fetch(appendV1RequestPath(baseUrl, 'models', queryParams), {
             headers: { ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}), ...headers },
             signal: controller.signal,
         });
-        clearTimeout(timer);
         if (!resp.ok)
             return { error: `HTTP ${resp.status}`, code: 'EXEC_FAILED' };
         const json = await resp.json().catch(() => null);
@@ -657,6 +664,10 @@ export async function gatewayModels(args) {
     catch (e) {
         return { error: `请求失败：${e?.message || e}`, code: 'EXEC_FAILED' };
     }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
     const evolcoreHome = resolvePaths().root;
     const now = Date.now();
     const models = arr.map((m) => {