codexmate 0.0.20 → 0.0.22

package/web-ui/modules/app.methods.navigation.mjs

@@ -277,6 +277,9 @@ export function createNavigationMethods(options = {}) {
                 : '';
             const targetTab = normalizedTab || tab;
             if (!targetTab) return;
+            if (targetTab === 'orchestration' && this.taskOrchestrationTabEnabled !== true) {
+                return this.switchMainTab('config');
+            }
             this.cancelTouchNavIntentReset();
             if (targetTab === 'sessions') {
                 this.cancelScheduledSessionTabDeferredTeardown();
@@ -297,6 +300,13 @@ export function createNavigationMethods(options = {}) {
             if (targetTab === previousTab) {
                 switchState.ticket += 1;
                 switchState.pendingTarget = '';
+                if (
+                    targetTab === 'sessions'
+                    && typeof this.prepareSessionTabRender === 'function'
+                    && (!this.sessionListRenderEnabled || !this.sessionPreviewRenderEnabled)
+                ) {
+                    this.prepareSessionTabRender();
+                }
                 this.scheduleAfterFrame(() => {
                     this.clearMainTabSwitchIntent(normalizedTab);
                 });
@@ -307,6 +317,9 @@ export function createNavigationMethods(options = {}) {
             if (isLeavingSessions && !this.isSessionPanelFastHidden()) {
                 this.setSessionPanelFastHidden(true);
             }
+            if (shouldDeferApply && typeof this.suspendSessionTabRender === 'function') {
+                this.suspendSessionTabRender();
+            }
             if (!shouldDeferApply) {
                 switchState.ticket += 1;
                 switchState.pendingTarget = '';
@@ -386,6 +399,116 @@ export function createNavigationMethods(options = {}) {
             this.__sessionTabDeferredTeardownHandle = null;
         },
 
+        setSessionListRef(element) {
+            this.__sessionListRef = element || null;
+            if (this.__sessionListRef && this.mainTab === 'sessions' && this.sessionListRenderEnabled) {
+                this.scheduleSessionListViewportFill();
+            }
+        },
+        getSessionListRenderSource() {
+            return Array.isArray(this.sortedSessionsList) ? this.sortedSessionsList : [];
+        },
+        cancelScheduledSessionListViewportFill() {
+            const handle = this.__sessionListViewportFillHandle || null;
+            if (!handle) return;
+            this.cancelIdleTask(handle);
+            this.__sessionListViewportFillHandle = null;
+        },
+        resetSessionListRender() {
+            this.cancelScheduledSessionListViewportFill();
+            this.sessionListVisibleCount = 0;
+        },
+        expandVisibleSessionList(stepSize, options = {}) {
+            const list = this.getSessionListRenderSource();
+            const total = list.length;
+            if (total <= 0) {
+                this.sessionListVisibleCount = 0;
+                return false;
+            }
+            const rawVisibleCount = Number(this.sessionListVisibleCount);
+            const currentCount = Number.isFinite(rawVisibleCount)
+                ? Math.max(0, Math.floor(rawVisibleCount))
+                : 0;
+            const initialBatchSize = Number.isFinite(this.sessionListInitialBatchSize)
+                ? Math.max(1, Math.floor(this.sessionListInitialBatchSize))
+                : 80;
+            const loadStep = Number.isFinite(stepSize)
+                ? Math.max(0, Math.floor(stepSize))
+                : (Number.isFinite(this.sessionListLoadStep)
+                    ? Math.max(1, Math.floor(this.sessionListLoadStep))
+                    : 120);
+            let nextCount = currentCount > 0
+                ? Math.min(total, currentCount + loadStep)
+                : Math.min(total, initialBatchSize);
+            if (options && options.ensureActive !== false) {
+                const activeKey = this.activeSession ? this.getSessionExportKey(this.activeSession) : '';
+                if (activeKey) {
+                    const activeIndex = list.findIndex((session) => this.getSessionExportKey(session) === activeKey);
+                    if (activeIndex >= 0) {
+                        nextCount = Math.max(nextCount, activeIndex + 1);
+                    }
+                }
+            }
+            nextCount = Math.min(total, nextCount);
+            if (nextCount <= currentCount) {
+                return false;
+            }
+            this.sessionListVisibleCount = nextCount;
+            return true;
+        },
+        scheduleSessionListViewportFill() {
+            this.cancelScheduledSessionListViewportFill();
+            if (this.mainTab !== 'sessions' || !this.sessionListRenderEnabled) {
+                return;
+            }
+            const run = () => {
+                this.__sessionListViewportFillHandle = null;
+                if (this.mainTab !== 'sessions' || !this.sessionListRenderEnabled) {
+                    return;
+                }
+                const list = this.getSessionListRenderSource();
+                const total = list.length;
+                const visibleCount = Number(this.sessionListVisibleCount);
+                const normalizedVisibleCount = Number.isFinite(visibleCount)
+                    ? Math.max(0, Math.floor(visibleCount))
+                    : 0;
+                if (total <= 0 || normalizedVisibleCount >= total) {
+                    return;
+                }
+                const listEl = this.__sessionListRef || null;
+                if (!listEl) {
+                    return;
+                }
+                const clientHeight = Number(listEl.clientHeight) || 0;
+                const scrollHeight = Number(listEl.scrollHeight) || 0;
+                const scrollTop = Number(listEl.scrollTop) || 0;
+                const remaining = Math.max(0, scrollHeight - scrollTop - clientHeight);
+                const shouldGrow = scrollHeight <= (clientHeight + 160) || remaining <= Math.max(160, clientHeight);
+                if (!shouldGrow) {
+                    return;
+                }
+                if (this.expandVisibleSessionList(undefined, { ensureActive: true })) {
+                    this.scheduleSessionListViewportFill();
+                }
+            };
+            this.__sessionListViewportFillHandle = this.scheduleIdleTask(run, 120);
+        },
+        primeSessionListRender() {
+            this.resetSessionListRender();
+            if (this.mainTab !== 'sessions' || !this.sessionListRenderEnabled) {
+                return;
+            }
+            this.expandVisibleSessionList(undefined, { ensureActive: true });
+            this.scheduleSessionListViewportFill();
+        },
+        onSessionListScroll(event) {
+            const nextRef = event && event.currentTarget ? event.currentTarget : this.__sessionListRef;
+            if (nextRef) {
+                this.__sessionListRef = nextRef;
+            }
+            this.scheduleSessionListViewportFill();
+        },
+
         resetSessionPreviewMessageRender() {
             this.sessionPreviewVisibleCount = 0;
             this.invalidateSessionTimelineMeasurementCache();
@@ -424,18 +547,21 @@ export function createNavigationMethods(options = {}) {
             this.sessionTabRenderTicket += 1;
             this.sessionListRenderEnabled = false;
             this.sessionPreviewRenderEnabled = false;
+            this.cancelScheduledSessionListViewportFill();
             this.cancelSessionTimelineSync();
             this.sessionTimelineActiveKey = '';
             this.sessionTimelineLastSyncAt = 0;
             this.sessionTimelineLastScrollTop = 0;
             this.sessionTimelineLastAnchorY = 0;
             this.sessionTimelineLastDirection = 0;
+            this.__sessionListRef = null;
             this.sessionPreviewScrollEl = null;
             this.sessionPreviewContainerEl = null;
             this.sessionPreviewHeaderEl = null;
         },
 
         finalizeSessionTabTeardown() {
+            this.resetSessionListRender();
             this.resetSessionPreviewMessageRender();
             this.sessionPreviewPendingVisibleCount = 0;
             this.clearSessionTimelineRefs();
@@ -450,6 +576,7 @@ export function createNavigationMethods(options = {}) {
             const ticket = ++this.sessionTabRenderTicket;
             this.sessionListRenderEnabled = false;
             this.sessionPreviewRenderEnabled = false;
+            this.resetSessionListRender();
             this.resetSessionPreviewMessageRender();
 
             this.scheduleAfterFrame(() => {
@@ -457,6 +584,7 @@ export function createNavigationMethods(options = {}) {
                     return;
                 }
                 this.sessionListRenderEnabled = true;
+                this.primeSessionListRender();
 
                 this.scheduleAfterFrame(() => {
                     if (ticket !== this.sessionTabRenderTicket || this.mainTab !== 'sessions') {
@@ -469,7 +597,20 @@ export function createNavigationMethods(options = {}) {
                         }
                         this.primeSessionPreviewMessageRender();
                         this.updateSessionTimelineOffset();
-                        this.scheduleSessionTimelineSync();
+                        if (!this.sessionTimelineEnabled) {
+                            return;
+                        }
+                        const syncTask = () => {
+                            if (ticket !== this.sessionTabRenderTicket || this.mainTab !== 'sessions') {
+                                return;
+                            }
+                            this.scheduleSessionTimelineSync();
+                        };
+                        if (typeof this.scheduleAfterFrame === 'function') {
+                            this.scheduleAfterFrame(syncTask);
+                            return;
+                        }
+                        syncTask();
                     });
                 });
             });

package/web-ui/modules/app.methods.openclaw-core.mjs

@@ -1,3 +1,229 @@
+function isPlainRecord(value) {
+    return !!(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function normalizeProviderId(provider) {
+    const normalized = typeof provider === 'string' ? provider.trim().toLowerCase() : '';
+    if (!normalized) return '';
+    if (normalized === 'modelstudio' || normalized === 'qwencloud') {
+        return 'qwen';
+    }
+    if (normalized === 'z.ai' || normalized === 'z-ai') {
+        return 'zai';
+    }
+    if (normalized === 'opencode-zen') {
+        return 'opencode';
+    }
+    if (normalized === 'opencode-go-auth') {
+        return 'opencode-go';
+    }
+    if (normalized === 'kimi' || normalized === 'kimi-code' || normalized === 'kimi-coding') {
+        return 'kimi';
+    }
+    if (normalized === 'bedrock' || normalized === 'aws-bedrock') {
+        return 'amazon-bedrock';
+    }
+    if (normalized === 'bytedance' || normalized === 'doubao') {
+        return 'volcengine';
+    }
+    return normalized;
+}
+
+function findNormalizedProviderKey(entries, provider) {
+    if (!isPlainRecord(entries)) {
+        return '';
+    }
+    const providerKey = normalizeProviderId(provider);
+    if (!providerKey) {
+        return '';
+    }
+    return Object.keys(entries).find((key) => normalizeProviderId(key) === providerKey) || '';
+}
+
+function collectDistinctProviderKeys(...providerMaps) {
+    const byNormalizedKey = new Map();
+    for (const providerMap of providerMaps) {
+        if (!isPlainRecord(providerMap)) continue;
+        for (const key of Object.keys(providerMap)) {
+            const normalizedKey = normalizeProviderId(key);
+            if (!normalizedKey || byNormalizedKey.has(normalizedKey)) continue;
+            byNormalizedKey.set(normalizedKey, key);
+        }
+    }
+    return Array.from(byNormalizedKey.values());
+}
+
+function isEnvTemplateString(value) {
+    return typeof value === 'string' && /^\$\{[A-Z][A-Z0-9_]{0,127}\}$/.test(value.trim());
+}
+
+function isSecretRefRecord(value) {
+    return isPlainRecord(value)
+        && typeof value.source === 'string'
+        && typeof value.provider === 'string'
+        && typeof value.id === 'string';
+}
+
+function isLegacySecretRefRecord(value) {
+    return isPlainRecord(value)
+        && typeof value.source === 'string'
+        && typeof value.id === 'string'
+        && (value.provider === undefined || value.provider === null || value.provider === '');
+}
+
+function coerceSecretRefRecord(value) {
+    if (isSecretRefRecord(value)) {
+        return {
+            source: value.source.trim(),
+            provider: value.provider.trim(),
+            id: value.id.trim()
+        };
+    }
+    if (isLegacySecretRefRecord(value)) {
+        return {
+            source: value.source.trim(),
+            provider: 'default',
+            id: value.id.trim()
+        };
+    }
+    return null;
+}
+
+const BUILTIN_PROVIDER_DEFAULTS = {
+    openai: {
+        baseUrl: 'https://api.openai.com/v1',
+        apiType: 'openai-responses'
+    },
+    'openai-codex': {
+        baseUrl: 'https://chatgpt.com/backend-api',
+        apiType: 'openai-codex-responses'
+    }
+};
+
+function formatSecretRefLabel(ref) {
+    const normalized = coerceSecretRefRecord(ref);
+    if (!normalized) return '';
+    return `SecretRef(${normalized.source}:${normalized.provider}:${normalized.id})`;
+}
+
+function readFirstProviderDisplayValue(records, keys) {
+    for (const record of records) {
+        if (!isPlainRecord(record)) continue;
+        for (const key of keys) {
+            if (typeof record[key] === 'string' && record[key].trim()) {
+                return {
+                    value: record[key].trim(),
+                    readOnly: false,
+                    kind: isEnvTemplateString(record[key]) ? 'env-template' : 'string'
+                };
+            }
+            if (coerceSecretRefRecord(record[key])) {
+                return {
+                    value: formatSecretRefLabel(record[key]),
+                    readOnly: true,
+                    kind: 'secret-ref'
+                };
+            }
+        }
+    }
+    return {
+        value: '',
+        readOnly: false,
+        kind: 'missing'
+    };
+}
+
+function readOpenclawAuthProfileDisplayValue(authProfilesByProvider, providerName) {
+    const matchedKey = findNormalizedProviderKey(authProfilesByProvider, providerName) || providerName;
+    const summary = isPlainRecord(authProfilesByProvider) ? authProfilesByProvider[matchedKey] : null;
+    if (!isPlainRecord(summary)) {
+        return {
+            value: '',
+            readOnly: false,
+            kind: 'missing',
+            sourceKind: '',
+            sourceProfileId: '',
+            sourceWriteField: '',
+            sourceOriginalValue: '',
+            sourceCredentialType: ''
+        };
+    }
+    if (typeof summary.resolvedValue === 'string' && summary.resolvedValue.trim()) {
+        return {
+            value: summary.resolvedValue.trim(),
+            readOnly: false,
+            kind: 'auth-profile-value',
+            sourceKind: 'auth-profile',
+            sourceProfileId: typeof summary.profileId === 'string' ? summary.profileId.trim() : '',
+            sourceWriteField: typeof summary.resolvedField === 'string' ? summary.resolvedField.trim() : '',
+            sourceOriginalValue: summary.resolvedValue.trim(),
+            sourceCredentialType: typeof summary.type === 'string' ? summary.type.trim() : ''
+        };
+    }
+    const resolvedField = typeof summary.resolvedField === 'string' ? summary.resolvedField.trim() : '';
+    if (summary.editable === true && resolvedField) {
+        return {
+            value: '',
+            readOnly: false,
+            kind: 'auth-profile-value',
+            sourceKind: 'auth-profile',
+            sourceProfileId: typeof summary.profileId === 'string' ? summary.profileId.trim() : '',
+            sourceWriteField: resolvedField,
+            sourceOriginalValue: '',
+            sourceCredentialType: typeof summary.type === 'string' ? summary.type.trim() : ''
+        };
+    }
+    if (typeof summary.display !== 'string' || !summary.display.trim()) {
+        return {
+            value: '',
+            readOnly: false,
+            kind: 'missing',
+            sourceKind: '',
+            sourceProfileId: '',
+            sourceWriteField: '',
+            sourceOriginalValue: '',
+            sourceCredentialType: ''
+        };
+    }
+    return {
+        value: summary.display.trim(),
+        readOnly: true,
+        kind: 'auth-profile',
+        sourceKind: '',
+        sourceProfileId: typeof summary.profileId === 'string' ? summary.profileId.trim() : '',
+        sourceWriteField: '',
+        sourceOriginalValue: '',
+        sourceCredentialType: typeof summary.type === 'string' ? summary.type.trim() : ''
+    };
+}
+
+function readBuiltinProviderDisplayValue(providerName, field) {
+    const defaults = BUILTIN_PROVIDER_DEFAULTS[normalizeProviderId(providerName)];
+    if (!defaults) {
+        return {
+            value: '',
+            readOnly: false,
+            kind: 'missing'
+        };
+    }
+    const key = field === 'apiType' ? 'apiType' : 'baseUrl';
+    const value = typeof defaults[key] === 'string' ? defaults[key].trim() : '';
+    return {
+        value,
+        readOnly: false,
+        kind: value ? 'builtin-default' : 'missing'
+    };
+}
+
+function readPreferredProviderModels(records) {
+    for (const record of records) {
+        if (isPlainRecord(record) && Array.isArray(record.models) && record.models.length) {
+            return record.models;
+        }
+    }
+    return [];
+}
+
 export function createOpenclawCoreMethods() {
     return {
         getOpenclawParser() {
@@ -68,7 +294,16 @@ export function createOpenclawCoreMethods() {
             return {
                 providerName: '',
                 baseUrl: '',
+                baseUrlReadOnly: false,
+                baseUrlDisplayKind: 'missing',
                 apiKey: '',
+                apiKeyReadOnly: false,
+                apiKeyDisplayKind: 'missing',
+                apiKeySourceKind: '',
+                apiKeySourceProfileId: '',
+                apiKeySourceWriteField: '',
+                apiKeySourceOriginalValue: '',
+                apiKeySourceCredentialType: '',
                 apiType: 'openai-responses',
                 modelId: '',
                 modelName: '',
@@ -89,24 +324,26 @@ export function createOpenclawCoreMethods() {
             this.openclawQuick.showKey = !this.openclawQuick.showKey;
         },
 
-        fillOpenclawQuickFromConfig(config) {
+        fillOpenclawQuickFromConfig(config, options = {}) {
             const defaults = this.getOpenclawQuickDefaults();
-            if (!config || typeof config !== 'object' || Array.isArray(config)) {
+            if (!isPlainRecord(config)) {
                 this.openclawQuick = defaults;
                 return;
             }
+            const authProfilesByProvider = isPlainRecord(options.authProfilesByProvider)
+                ? options.authProfilesByProvider
+                : (isPlainRecord(this.openclawAuthProfilesByProvider) ? this.openclawAuthProfilesByProvider : {});
 
-            const agentDefaults = config.agents && typeof config.agents === 'object' && !Array.isArray(config.agents)
-                && config.agents.defaults && typeof config.agents.defaults === 'object' && !Array.isArray(config.agents.defaults)
+            const agentDefaults = isPlainRecord(config.agents) && isPlainRecord(config.agents.defaults)
                 ? config.agents.defaults
                 : {};
             const modelConfig = agentDefaults.model;
-            const legacyAgent = config.agent && typeof config.agent === 'object' && !Array.isArray(config.agent)
+            const legacyAgent = isPlainRecord(config.agent)
                 ? config.agent
                 : {};
 
             let primaryRef = '';
-            if (modelConfig && typeof modelConfig === 'object' && !Array.isArray(modelConfig) && typeof modelConfig.primary === 'string') {
+            if (isPlainRecord(modelConfig) && typeof modelConfig.primary === 'string') {
                 primaryRef = modelConfig.primary;
             } else if (typeof modelConfig === 'string') {
                 primaryRef = modelConfig;
@@ -114,7 +351,7 @@ export function createOpenclawCoreMethods() {
             if (!primaryRef) {
                 if (typeof legacyAgent.model === 'string') {
                     primaryRef = legacyAgent.model;
-                } else if (legacyAgent.model && typeof legacyAgent.model === 'object' && typeof legacyAgent.model.primary === 'string') {
+                } else if (isPlainRecord(legacyAgent.model) && typeof legacyAgent.model.primary === 'string') {
                     primaryRef = legacyAgent.model.primary;
                 }
             }
@@ -129,56 +366,109 @@ export function createOpenclawCoreMethods() {
                 }
             }
 
-            const providers = config.models && typeof config.models === 'object' && !Array.isArray(config.models)
-                && config.models.providers && typeof config.models.providers === 'object' && !Array.isArray(config.models.providers)
+            const modelProviders = isPlainRecord(config.models) && isPlainRecord(config.models.providers)
                 ? config.models.providers
                 : null;
-            let providerConfig = providerName && providers ? providers[providerName] : null;
-            if (!providerName && providers) {
-                const providerKeys = Object.keys(providers);
-                if (providerKeys.length === 1) {
-                    providerName = providerKeys[0];
-                    providerConfig = providers[providerName];
-                }
+            const rootProviders = isPlainRecord(config.providers)
+                ? config.providers
+                : null;
+            const providerKeys = collectDistinctProviderKeys(modelProviders, rootProviders);
+            if (!providerName && providerKeys.length === 1) {
+                providerName = providerKeys[0];
+            }
+
+            const normalizedConfiguredProviderName = providerName
+                ? (findNormalizedProviderKey(modelProviders, providerName)
+                    || findNormalizedProviderKey(rootProviders, providerName)
+                    || providerName)
+                : '';
+            if (normalizedConfiguredProviderName) {
+                providerName = normalizedConfiguredProviderName;
             }
 
+            const buildProviderRecords = (name) => {
+                if (!name) return [];
+                const modelProviderKey = findNormalizedProviderKey(modelProviders, name) || name;
+                const rootProviderKey = findNormalizedProviderKey(rootProviders, name) || name;
+                return [
+                    modelProviders && modelProviders[modelProviderKey],
+                    rootProviders && rootProviders[rootProviderKey]
+                ];
+            };
+            let providerRecords = buildProviderRecords(providerName);
+            const hasProviderConfig = providerRecords.some((item) => isPlainRecord(item));
+            if (!hasProviderConfig && providerKeys.length === 1) {
+                providerName = providerKeys[0];
+                providerRecords = buildProviderRecords(providerName);
+            }
+            const providerConfig = providerRecords.find((item) => isPlainRecord(item)) || null;
+            const providerModels = readPreferredProviderModels(providerRecords);
+
             let modelEntry = null;
-            if (providerConfig && typeof providerConfig === 'object' && Array.isArray(providerConfig.models)) {
+            if (providerModels.length) {
                 if (modelId) {
-                    modelEntry = providerConfig.models.find(item => item && item.id === modelId);
+                    modelEntry = providerModels.find(item => item && (item.id === modelId || item.model === modelId));
                 }
-                if (!modelEntry && providerConfig.models.length === 1) {
-                    modelEntry = providerConfig.models[0];
-                    if (!modelId && modelEntry && typeof modelEntry.id === 'string') {
-                        modelId = modelEntry.id;
+                if (!modelEntry && providerModels.length === 1) {
+                    modelEntry = providerModels[0];
+                    if (!modelId && modelEntry) {
+                        if (typeof modelEntry.id === 'string' && modelEntry.id.trim()) {
+                            modelId = modelEntry.id.trim();
+                        } else if (typeof modelEntry.model === 'string' && modelEntry.model.trim()) {
+                            modelId = modelEntry.model.trim();
+                        }
                     }
                 }
             }
 
-            const baseUrl = providerConfig && typeof providerConfig === 'object' && typeof providerConfig.baseUrl === 'string'
-                ? providerConfig.baseUrl
-                : '';
-            const apiKey = providerConfig && typeof providerConfig === 'object' && typeof providerConfig.apiKey === 'string'
-                ? providerConfig.apiKey
-                : '';
-            const apiType = providerConfig && typeof providerConfig === 'object' && typeof providerConfig.api === 'string'
-                ? providerConfig.api
-                : defaults.apiType;
+            const configuredBaseUrlField = readFirstProviderDisplayValue(providerRecords, ['baseUrl', 'base_url', 'url']);
+            const baseUrlField = configuredBaseUrlField.value
+                ? configuredBaseUrlField
+                : readBuiltinProviderDisplayValue(providerName, 'baseUrl');
+            const providerApiKeyField = readFirstProviderDisplayValue(providerRecords, ['apiKey', 'api_key', 'keyRef', 'key', 'authToken', 'auth_token', 'tokenRef', 'token']);
+            const authProfileField = providerName
+                ? readOpenclawAuthProfileDisplayValue(authProfilesByProvider, providerName)
+                : {
+                    value: '',
+                    readOnly: false,
+                    kind: 'missing',
+                    sourceKind: '',
+                    sourceProfileId: '',
+                    sourceWriteField: '',
+                    sourceOriginalValue: '',
+                    sourceCredentialType: ''
+                };
+            const apiKeyField = providerApiKeyField.value ? providerApiKeyField : authProfileField;
+            const configuredApiTypeField = readFirstProviderDisplayValue(providerRecords, ['api', 'apiType', 'api_type']);
+            const apiTypeField = configuredApiTypeField.value
+                ? configuredApiTypeField
+                : readBuiltinProviderDisplayValue(providerName, 'apiType');
 
             this.openclawQuick = {
                 ...defaults,
                 providerName,
-                baseUrl,
-                apiKey,
-                apiType,
+                baseUrl: baseUrlField.value,
+                baseUrlReadOnly: baseUrlField.readOnly,
+                baseUrlDisplayKind: baseUrlField.kind,
+                apiKey: apiKeyField.value,
+                apiKeyReadOnly: apiKeyField.readOnly,
+                apiKeyDisplayKind: apiKeyField.kind,
+                apiKeySourceKind: apiKeyField.sourceKind || '',
+                apiKeySourceProfileId: apiKeyField.sourceProfileId || '',
+                apiKeySourceWriteField: apiKeyField.sourceWriteField || '',
+                apiKeySourceOriginalValue: apiKeyField.sourceOriginalValue || '',
+                apiKeySourceCredentialType: apiKeyField.sourceCredentialType || '',
+                apiType: apiTypeField.value || defaults.apiType,
                 modelId: modelId || '',
-                modelName: modelEntry && typeof modelEntry.name === 'string' ? modelEntry.name : '',
+                modelName: modelEntry && typeof modelEntry.name === 'string'
+                    ? modelEntry.name
+                    : (modelEntry && typeof modelEntry.displayName === 'string' ? modelEntry.displayName : ''),
                 contextWindow: modelEntry && typeof modelEntry.contextWindow === 'number'
                     ? String(modelEntry.contextWindow)
-                    : '',
+                    : (modelEntry && typeof modelEntry.context_window === 'number' ? String(modelEntry.context_window) : ''),
                 maxTokens: modelEntry && typeof modelEntry.maxTokens === 'number'
                     ? String(modelEntry.maxTokens)
-                    : ''
+                    : (modelEntry && typeof modelEntry.max_tokens === 'number' ? String(modelEntry.max_tokens) : '')
             };
         },
 
@@ -192,7 +482,9 @@ export function createOpenclawCoreMethods() {
                 }
                 return false;
             }
-            this.fillOpenclawQuickFromConfig(parsed.data);
+            this.fillOpenclawQuickFromConfig(parsed.data, {
+                authProfilesByProvider: this.openclawAuthProfilesByProvider
+            });
             if (!silent) {
                 this.showMessage('已读取配置', 'success');
             }
@@ -291,7 +583,9 @@ export function createOpenclawCoreMethods() {
                 return false;
             }
             this.fillOpenclawStructured(parsed.data);
-            this.fillOpenclawQuickFromConfig(parsed.data);
+            this.fillOpenclawQuickFromConfig(parsed.data, {
+                authProfilesByProvider: this.openclawAuthProfilesByProvider
+            });
             this.refreshOpenclawProviders(parsed.data);
             this.refreshOpenclawAgentsList(parsed.data);
             if (!silent) {
@@ -361,6 +655,9 @@ export function createOpenclawCoreMethods() {
             if (typeof value === 'undefined' || value === null) {
                 return '';
             }
+            if (coerceSecretRefRecord(value)) {
+                return formatSecretRefLabel(value);
+            }
             let text = '';
             if (typeof value === 'string') {
                 text = value;
@@ -374,6 +671,9 @@ export function createOpenclawCoreMethods() {
                 }
             }
             if (!text) return '';
+            if (isEnvTemplateString(text)) {
+                return `EnvRef(${text.trim().slice(2, -1)})`;
+            }
             if (/key|token|secret|password/i.test(key)) {
                 return this.maskProviderValue(text);
             }