@yeaft/webchat-agent 0.1.937 → 0.1.939

package/connection/message-router.js

@@ -337,7 +337,25 @@ export async function handleMessage(msg) {
 
     // LLM configuration (read/write ~/.yeaft/config.json)
     case 'get_llm_config': {
-      const config = getLlmConfig(ctx.CONFIG?.yeaftDir);
+      if (msg.globalConfig && typeof msg.globalConfig === 'object') {
+        ctx.globalLlmConfig = msg.globalConfig;
+      }
+      const config = getLlmConfig(ctx.CONFIG?.yeaftDir, ctx.globalLlmConfig);
+      sendToServer({ type: 'llm_config', ...config });
+      break;
+    }
+
+    case 'llm_global_config_updated': {
+      ctx.globalLlmConfig = msg.globalConfig && typeof msg.globalConfig === 'object'
+        ? msg.globalConfig
+        : { providers: [] };
+      // Existing sessions cache AdapterRouter instances. Drop them so the
+      // next Yeaft turn sees the new global providers, without writing them
+      // to the node-local config.json.
+      resetYeaftSession().catch(err => {
+        console.error('[LLM] Failed to reload Yeaft session after global config update:', err.message);
+      });
+      const config = getLlmConfig(ctx.CONFIG?.yeaftDir, ctx.globalLlmConfig);
       sendToServer({ type: 'llm_config', ...config });
       break;
     }
@@ -351,7 +369,10 @@ export async function handleMessage(msg) {
       const incomingLanguage = typeof msg.config?.language === 'string' && msg.config.language
         ? msg.config.language
         : null;
-      const result = updateLlmConfig(msg.config || {}, ctx.CONFIG?.yeaftDir);
+      if (msg.globalConfig && typeof msg.globalConfig === 'object') {
+        ctx.globalLlmConfig = msg.globalConfig;
+      }
+      const result = updateLlmConfig(msg.config || {}, ctx.CONFIG?.yeaftDir, ctx.globalLlmConfig);
       // task-708: live locale propagation. When the user flips the UI
       // language dropdown, push the new value into every cached Engine
       // (per-VP pool + 1:1 chat session.engine) so the very next turn
@@ -362,6 +383,11 @@ export async function handleMessage(msg) {
       }
       if (!result.error) {
         refreshYeaftStatus({ reason: 'llm_config_updated' }).catch(() => {});
+        if (!incomingLanguage) {
+          resetYeaftSession().catch(err => {
+            console.error('[LLM] Failed to reload Yeaft session after local config update:', err.message);
+          });
+        }
       }
       sendToServer({ type: 'llm_config_updated', ...result });
       break;

package/context.js

@@ -18,6 +18,8 @@ export default {
   slashCommandDescriptions: {},
   // MCP servers 列表 (从 ~/.claude.json 读取): [{ name, enabled, source }]
   mcpServers: [],
+  // Server-owned user-global LLM providers. Runtime-only: never persisted to ~/.yeaft/config.json.
+  globalLlmConfig: { providers: [] },
   // 连接相关
   reconnectTimer: null,
   pendingAuthTempId: null,

package/conversation.js

@@ -457,11 +457,19 @@ export async function resumeConversation(msg) {
     if (id === conversationId || (claudeSessionId && conv.claudeSessionId === claudeSessionId)) {
       console.log(`[Resume] Cleaning up old conversation: ${id} (claudeSessionId: ${conv.claudeSessionId})`);
       if (conv.providerOptions && !priorProviderOptions) priorProviderOptions = conv.providerOptions;
-      if (conv.abortController) {
-        conv.abortController.abort();
-      }
-      if (conv.inputStream) {
-        try { conv.inputStream.done(); } catch {}
+      let cleanupDriver = null;
+      try {
+        cleanupDriver = getProvider(conv.providerName || provider || DEFAULT_PROVIDER);
+      } catch { /* fallback to legacy cleanup below */ }
+      if (typeof cleanupDriver?.dispose === 'function') {
+        cleanupDriver.dispose(conv, 'resume cleanup');
+      } else {
+        if (conv.abortController) {
+          conv.abortController.abort();
+        }
+        if (conv.inputStream) {
+          try { conv.inputStream.done(); } catch {}
+        }
       }
       ctx.conversations.delete(id);
     }
@@ -783,17 +791,23 @@ export async function handleUserInput(msg) {
 
     // /clear for capable providers — reset session in-place without spawning new turn
     if (slashCommand.type === 'slash' && slashCommand.command === '/clear') {
+      state.turnActive = true;
+      state.turnCompletedEmitted = false;
+      state.turnErrorEmitted = false;
       if (typeof driver.clear === 'function' && driver.capabilities?.clear) {
         try { await driver.clear(state); } catch (err) {
           console.warn(`[${conversationId}] driver.clear failed:`, err?.message || err);
         }
       }
-      ctx.sendToServer({
-        type: 'turn_completed',
-        conversationId,
-        claudeSessionId: state.sessionId || state.claudeSessionId,
-        workDir: state.workDir
-      });
+      if (!state.turnCompletedEmitted) {
+        ctx.sendToServer({
+          type: 'turn_completed',
+          conversationId,
+          claudeSessionId: state.sessionId || state.claudeSessionId,
+          workDir: state.workDir
+        });
+      }
+      state.turnActive = false;
       return;
     }
 
@@ -812,6 +826,10 @@ export async function handleUserInput(msg) {
       });
     } finally {
       state.turnActive = false;
+      if (state._abortKillTimer) {
+        clearTimeout(state._abortKillTimer);
+        state._abortKillTimer = null;
+      }
       sendConversationList();
     }
     return;
@@ -976,7 +994,7 @@ export function handleAskUserAnswer(msg) {
         if (typeof driver.respondToPermissionRequest === 'function') {
           const ans = msg.answers || {};
           const optionId = typeof ans === 'string' ? ans
-            : ans.optionId || ans.option || Object.values(ans)[0];
+            : ans.optionId || ans.option || ans['Copilot permission'] || Object.values(ans)[0];
           driver.respondToPermissionRequest(state, msg.requestId, optionId);
           return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.937",
+  "version": "0.1.939",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/providers/copilot.js

@@ -38,12 +38,7 @@ export async function start(opts) {
   const conversationId = opts.conversationId;
   // Tear down any prior entry so we don't leak children.
   const prior = ctx.conversations.get(conversationId);
-  if (prior?.copilotChild) {
-    try { prior.copilotChild.kill('SIGTERM'); } catch { /* noop */ }
-  }
-  if (prior?.acpClient) {
-    try { prior.acpClient.close('replaced'); } catch { /* noop */ }
-  }
+  dispose(prior, 'replaced');
 
   const providerOptions = opts.providerOptions || prior?.providerOptions || {};
   const model = providerOptions.model || DEFAULT_COPILOT_MODEL;
@@ -116,31 +111,16 @@ async function _bootAcp(state, resumeSessionId, model) {
     }
   });
   child.on('error', (err) => {
-    sendOutput(state.conversationId, {
-      type: 'result',
-      subtype: 'error',
-      session_id: state.sessionId,
-      is_error: true,
-      error: `copilot process error: ${err?.message || err}`,
-    });
+    _sendTurnError(state, `copilot process error: ${err?.message || err}`);
   });
   child.on('close', (code) => {
     if (state.turnActive) {
       const tail = stderrBuf.trim().slice(-2000);
-      sendOutput(state.conversationId, {
-        type: 'result',
-        subtype: 'error',
-        session_id: state.sessionId,
-        is_error: true,
-        error: tail || `copilot exited mid-turn (code ${code})`,
-      });
-      ctx.sendToServer({
-        type: 'turn_completed',
-        conversationId: state.conversationId,
-        claudeSessionId: state.sessionId,
-        workDir: state.workDir,
-      });
-      state.turnActive = false;
+      _sendTurnError(state, tail || `copilot exited mid-turn (code ${code})`);
+      _completeTurn(state);
+    }
+    if (state.acpClient) {
+      try { state.acpClient.close(`copilot exited (code ${code})`); } catch { /* noop */ }
     }
     // Drain any in-flight permission prompts so the frontend dialog unwedges
     // and the Promise GC roots release.
@@ -180,6 +160,7 @@ async function _bootAcp(state, resumeSessionId, model) {
     state.claudeSessionId = resumeSessionId;
     if (Array.isArray(r?.modes?.availableModes)) state.acpModes = r.modes.availableModes;
     if (Array.isArray(r?.models?.availableModels)) cacheCopilotModelsFromAcp(r.models.availableModels);
+    _sendSessionIdUpdate(state);
   } else {
     if (resumeSessionId && !state.acpCapabilities.loadSession) {
       // Surface the downgrade — silently handing back a fresh session would
@@ -198,6 +179,7 @@ async function _bootAcp(state, resumeSessionId, model) {
     state.claudeSessionId = state.sessionId;
     if (Array.isArray(r?.modes?.availableModes)) state.acpModes = r.modes.availableModes;
     if (Array.isArray(r?.models?.availableModels)) cacheCopilotModelsFromAcp(r.models.availableModels);
+    _sendSessionIdUpdate(state);
   }
 
   // 3) Emit a system_init envelope so the UI populates tools / model panels.
@@ -224,14 +206,8 @@ export async function sendInput(state, prompt, opts = {}) {
     try {
       await _bootAcp(state, state.sessionId || null, state.model);
     } catch (err) {
-      sendOutput(conversationId, {
-        type: 'result',
-        subtype: 'error',
-        session_id: state.sessionId,
-        is_error: true,
-        error: `copilot ACP reinit failed: ${err?.message || err}`,
-      });
-      ctx.sendToServer({ type: 'turn_completed', conversationId, claudeSessionId: state.sessionId, workDir: state.workDir });
+      _sendTurnError(state, `copilot ACP reinit failed: ${err?.message || err}`);
+      _completeTurn(state, conversationId);
       return;
     }
   }
@@ -247,6 +223,8 @@ export async function sendInput(state, prompt, opts = {}) {
   const abortController = new AbortController();
   state.abortController = abortController;
   state.turnActive = true;
+  state.turnCompletedEmitted = false;
+  state.turnErrorEmitted = false;
   state.turnResultReceived = false;
 
   // Build prompt content blocks. ACP ContentBlock variants: text, image,
@@ -289,21 +267,9 @@ export async function sendInput(state, prompt, opts = {}) {
       error: isErr ? `copilot stop_reason=${stopReason}` : undefined,
     });
   } catch (err) {
-    sendOutput(conversationId, {
-      type: 'result',
-      subtype: 'error',
-      session_id: state.sessionId,
-      is_error: true,
-      error: err?.message || String(err),
-    });
+    _sendTurnError(state, err?.message || String(err));
   } finally {
-    state.turnActive = false;
-    ctx.sendToServer({
-      type: 'turn_completed',
-      conversationId,
-      claudeSessionId: state.sessionId,
-      workDir: state.workDir,
-    });
+    _completeTurn(state, conversationId);
   }
 }
 
@@ -330,12 +296,44 @@ export function abort(state) {
   }
 }
 
+export function dispose(state, reason = 'disposed') {
+  if (!state) return;
+  if (state.abortController) {
+    try { state.abortController.abort(); } catch { /* noop */ }
+    state.abortController = null;
+  }
+  if (state._abortKillTimer) {
+    clearTimeout(state._abortKillTimer);
+    state._abortKillTimer = null;
+  }
+  _drainPendingPermissions(state, reason);
+  if (state.acpClient) {
+    try { state.acpClient.close(reason); } catch { /* noop */ }
+    state.acpClient = null;
+  }
+  if (state.copilotChild) {
+    try { state.copilotChild.kill('SIGTERM'); } catch { /* noop */ }
+    state.copilotChild = null;
+  }
+  state.initialized = false;
+  state.turnActive = false;
+}
+
 /**
  * /clear support: ask ACP for a brand-new session under the same
  * conversationId. Keeps the child alive — no spawn cost.
  */
 export async function clear(state) {
-  if (!state?.acpClient) return;
+  if (!state) return;
+  if (!state.initialized || !state.acpClient) {
+    try {
+      await _bootAcp(state, null, state.model);
+      return;
+    } catch (err) {
+      _sendTurnError(state, `copilot ACP reinit failed during clear: ${err?.message || err}`);
+      return;
+    }
+  }
   // A fresh session invalidates any in-flight permission prompts.
   _drainPendingPermissions(state, 'session cleared');
   try {
@@ -345,6 +343,7 @@ export async function clear(state) {
     });
     state.sessionId = r?.sessionId || randomUUID();
     state.claudeSessionId = state.sessionId;
+    _sendSessionIdUpdate(state);
     sendOutput(state.conversationId, {
       type: 'system',
       subtype: 'init',
@@ -355,6 +354,7 @@ export async function clear(state) {
       permissionMode: state.allowAllTools ? 'bypassPermissions' : 'default',
     });
   } catch (err) {
+    _sendTurnError(state, `copilot clear failed: ${err?.message || err}`);
     if (ctx?.CONFIG?.debug) console.warn('[copilot] clear failed:', err?.message || err);
   }
 }
@@ -365,6 +365,40 @@ function sendOutput(conversationId, data) {
   ctx.sendToServer({ type: 'claude_output', conversationId, data });
 }
 
+function _sendSessionIdUpdate(state) {
+  if (!state?.conversationId || !state.sessionId) return;
+  ctx.sendToServer({
+    type: 'session_id_update',
+    conversationId: state.conversationId,
+    claudeSessionId: state.sessionId,
+    workDir: state.workDir,
+  });
+}
+
+function _sendTurnError(state, error) {
+  if (!state || state.turnErrorEmitted) return;
+  state.turnErrorEmitted = true;
+  sendOutput(state.conversationId, {
+    type: 'result',
+    subtype: 'error',
+    session_id: state.sessionId,
+    is_error: true,
+    error,
+  });
+}
+
+function _completeTurn(state, conversationId = state?.conversationId) {
+  if (!state || state.turnCompletedEmitted) return;
+  state.turnCompletedEmitted = true;
+  state.turnActive = false;
+  ctx.sendToServer({
+    type: 'turn_completed',
+    conversationId,
+    claudeSessionId: state.sessionId,
+    workDir: state.workDir,
+  });
+}
+
 function _handleAcpNotification(state, method, params) {
   if (method === 'session/update') {
     _handleSessionUpdate(state, params);
@@ -474,19 +508,36 @@ async function _handlePermissionRequest(state, params) {
     const allow = opt.find(o => o.kind === 'allow_always' || o.kind === 'allow_once') || opt[0];
     return { outcome: { outcome: 'selected', optionId: allow.optionId } };
   }
-  // Otherwise route through the existing ask-user wire path. We do it inline
-  // here using a per-state Promise; the frontend responds via the standard
-  // `ask_user_response` message which conversation.js routes back into the
-  // driver via `respondToPermissionRequest(state, requestId, optionId)`.
+  // Otherwise route through the existing AskUserQuestion UI. Emit the same
+  // Claude-style tool_use first, then link it with ask_user_question so the
+  // regular card renders and answer routing can stay provider-agnostic.
   const requestId = `copilot-perm-${randomUUID()}`;
+  const question = _formatPermissionPrompt(params);
+  const questions = [{
+    header: 'Copilot permission',
+    question,
+    options: opt.map(o => ({ label: o.name || o.optionId })),
+    multiSelect: false,
+  }];
+  sendOutput(state.conversationId, {
+    type: 'assistant',
+    message: {
+      role: 'assistant',
+      content: [{
+        type: 'tool_use',
+        id: requestId,
+        name: 'AskUserQuestion',
+        input: { questions },
+      }],
+    },
+  });
   return new Promise((resolve) => {
     state.pendingPermissions.set(requestId, { resolve, options: opt });
     ctx.sendToServer({
       type: 'ask_user_question',
       conversationId: state.conversationId,
       requestId,
-      question: _formatPermissionPrompt(params),
-      options: opt.map(o => ({ id: o.optionId, label: o.name || o.optionId, kind: o.kind })),
+      questions,
     });
   });
 }
@@ -518,7 +569,7 @@ export function respondToPermissionRequest(state, requestId, optionId) {
     return false;
   }
   state.pendingPermissions.delete(requestId);
-  const opt = slot.options.find(o => o.optionId === optionId) || slot.options[0];
+  const opt = slot.options.find(o => o.optionId === optionId || o.name === optionId) || slot.options[0];
   slot.resolve({ outcome: { outcome: 'selected', optionId: opt?.optionId || optionId } });
   return true;
 }

package/yeaft/config-api.js

@@ -13,6 +13,7 @@ import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
 import { normalizeProviderModels, serializeModelForPersistence } from './models.js';
 import { normaliseYeaftSection } from './config.js';
+import { mergeLlmConfigs } from './llm/provider-merge.js';
 
 /**
  * Read the LLM-relevant portion of config.json.
@@ -20,7 +21,7 @@ import { normaliseYeaftSection } from './config.js';
  * @param {string} [dir] — Yeaft data directory
  * @returns {{ providers, primaryModel, fastModel, language } | { error: string }}
  */
-export function getLlmConfig(dir) {
+function readLocalLlmConfig(dir) {
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
   const configPath = join(root, 'config.json');
 
@@ -28,22 +29,27 @@ export function getLlmConfig(dir) {
     return { providers: [], primaryModel: null, fastModel: null, language: 'en', needsSetup: true };
   }
 
-  try {
-    const raw = readFileSync(configPath, 'utf8');
-    const json = JSON.parse(raw);
-    const providers = Array.isArray(json.providers) ? json.providers : [];
-
-    // Detect if config still has default/placeholder values (first-time setup needed)
-    const needsSetup = providers.length === 0 || providers.every(p =>
-      p.apiKey === 'proxy' || p.apiKey === '' || !p.apiKey
-    );
+  const raw = readFileSync(configPath, 'utf8');
+  const json = JSON.parse(raw);
+  const providers = Array.isArray(json.providers) ? json.providers : [];
+  return {
+    providers,
+    primaryModel: json.primaryModel || null,
+    fastModel: json.fastModel || null,
+    language: json.language || 'en',
+    needsSetup: providers.length === 0 || providers.every(p => p.apiKey === 'proxy' || p.apiKey === '' || (!p.apiKey && !p.credentialProvider)),
+  };
+}
 
+export function getLlmConfig(dir, globalConfig = {}) {
+  try {
+    const agentConfig = readLocalLlmConfig(dir);
+    const effectiveConfig = mergeLlmConfigs(globalConfig, agentConfig);
     return {
-      providers,
-      primaryModel: json.primaryModel || null,
-      fastModel: json.fastModel || null,
-      language: json.language || 'en',
-      needsSetup,
+      ...effectiveConfig,
+      agentConfig,
+      effectiveConfig,
+      globalConfig: { providers: Array.isArray(globalConfig.providers) ? globalConfig.providers : [] },
     };
   } catch (e) {
     return { error: `Failed to read config.json: ${e.message}` };
@@ -58,7 +64,7 @@ export function getLlmConfig(dir) {
  * @param {string} [dir] — Yeaft data directory
  * @returns {{ providers, primaryModel, fastModel, language } | { error: string }}
  */
-export function updateLlmConfig(update, dir) {
+export function updateLlmConfig(update, dir, globalConfig = {}) {
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
   const configPath = join(root, 'config.json');
 
@@ -120,12 +126,19 @@ export function updateLlmConfig(update, dir) {
     return { error: `Failed to write config.json: ${e.message}` };
   }
 
-  return {
+  const agentConfig = {
     providers: Array.isArray(existing.providers) ? existing.providers : [],
     primaryModel: existing.primaryModel || null,
     fastModel: existing.fastModel || null,
     language: existing.language || 'en',
   };
+  const effectiveConfig = mergeLlmConfigs(globalConfig, agentConfig);
+  return {
+    ...effectiveConfig,
+    agentConfig,
+    effectiveConfig,
+    globalConfig: { providers: Array.isArray(globalConfig.providers) ? globalConfig.providers : [] },
+  };
 }
 
 // ─── Yeaft runtime settings (task-318) ────────────────────────────

package/yeaft/config.js

@@ -23,6 +23,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
 import { resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
+import { mergeLlmConfigs } from './llm/provider-merge.js';
 
 /** Default configuration values. */
 const DEFAULTS = {
@@ -294,36 +295,47 @@ export function loadConfig(overrides = {}) {
   }
 
   // ─── Build config from config.json ────────────────────────
-  const providers = Array.isArray(jsonConfig.providers) ? jsonConfig.providers : null;
+  const agentProviders = Array.isArray(jsonConfig.providers) ? jsonConfig.providers : [];
+  const mergedLlmConfig = mergeLlmConfigs(overrides.globalLlmConfig || {}, {
+    providers: agentProviders,
+    primaryModel: jsonConfig.primaryModel || null,
+    fastModel: jsonConfig.fastModel || null,
+    language: jsonConfig.language || DEFAULTS.language,
+  });
+  const providers = mergedLlmConfig.providers;
 
   // Resolve primary model
   let model = 'claude-sonnet-4-20250514';
-  let primaryModel = jsonConfig.primaryModel || null;
+  let modelIdForInfo = model;
+  let primaryModel = mergedLlmConfig.primaryModel || null;
   if (primaryModel) {
     const parsed = parseModelRef(primaryModel);
-    model = parsed.modelId;
+    model = parsed.providerName?.startsWith('global:') ? primaryModel : parsed.modelId;
+    modelIdForInfo = parsed.modelId;
   }
 
   // Resolve fast model
-  let fastModel = jsonConfig.fastModel || primaryModel || null;
+  let fastModel = mergedLlmConfig.fastModel || primaryModel || null;
   let fastModelId = null;
   if (fastModel) {
     const parsed = parseModelRef(fastModel);
-    fastModelId = parsed.modelId;
+    fastModelId = parsed.providerName?.startsWith('global:') ? fastModel : parsed.modelId;
   }
 
   // Resolve model info for adapter/baseUrl/thinking metadata. Token limits
   // (contextWindow / maxOutputTokens) are NOT read from here — they live in
   // models.dev and are resolved via resolveContextWindow / resolveMaxOutputTokens
   // a few lines below so the live models.dev snapshot is the source of truth.
-  const modelInfo = resolveModel(model);
+  // For disambiguated global provider refs (`global:<provider>/<model>`), keep
+  // the runtime model ref intact above but resolve metadata by the raw model id.
+  const modelInfo = resolveModel(modelIdForInfo);
 
   // Pre-resolve token limits once so we can both write them onto config and
   // pass `config` to the resolver chain consistently below.
   const resolvedMaxContext = overrides.maxContextTokens ?? jsonConfig.maxContextTokens
-    ?? resolveContextWindow(model, { modelInfo });
+    ?? resolveContextWindow(modelIdForInfo, { modelInfo });
   const resolvedMaxOutput = overrides.maxOutputTokens ?? jsonConfig.maxOutputTokens
-    ?? resolveMaxOutputTokens(model, { modelInfo });
+    ?? resolveMaxOutputTokens(modelIdForInfo, { modelInfo });
 
   const config = {
     // Model
@@ -335,7 +347,7 @@ export function loadConfig(overrides = {}) {
     modelInfo: modelInfo || null,
 
     // Providers
-    providers: providers,
+    providers: providers.length > 0 ? providers : null,
 
     // General settings
     language: overrides.language || jsonConfig.language || DEFAULTS.language,

package/yeaft/llm/provider-merge.js

@@ -0,0 +1,53 @@
+function cloneProvider(provider, scope) {
+  return {
+    ...provider,
+    scope,
+    source: scope,
+    originalName: provider.name,
+    models: Array.isArray(provider.models)
+      ? provider.models.map(m => (m && typeof m === 'object' ? { ...m } : m))
+      : [],
+  };
+}
+
+function modelId(entry) {
+  if (typeof entry === 'string') return entry;
+  if (entry && typeof entry === 'object' && typeof entry.id === 'string') return entry.id;
+  return '';
+}
+
+export function buildModelRef(provider, entry) {
+  const id = modelId(entry);
+  return provider?.name && id ? `${provider.name}/${id}` : id;
+}
+
+export function mergeLlmConfigs(globalConfig = {}, agentConfig = {}) {
+  const agentProviders = Array.isArray(agentConfig.providers)
+    ? agentConfig.providers.map(p => cloneProvider(p, 'agent'))
+    : [];
+  const localNames = new Set(agentProviders.map(p => p.name).filter(Boolean));
+  const usedNames = new Set(localNames);
+  const globalProviders = [];
+
+  for (const raw of Array.isArray(globalConfig.providers) ? globalConfig.providers : []) {
+    if (!raw?.name) continue;
+    const provider = cloneProvider(raw, 'global');
+    if (usedNames.has(provider.name)) {
+      let candidate = `global:${provider.name}`;
+      let i = 2;
+      while (usedNames.has(candidate)) candidate = `global:${provider.name}:${i++}`;
+      provider.name = candidate;
+    }
+    usedNames.add(provider.name);
+    globalProviders.push(provider);
+  }
+
+  const providers = [...globalProviders, ...agentProviders];
+  return {
+    providers,
+    primaryModel: agentConfig.primaryModel || null,
+    fastModel: agentConfig.fastModel || null,
+    language: agentConfig.language || 'en',
+    needsSetup: providers.length === 0 || providers.every(p => (!p.apiKey || p.apiKey === 'proxy') && !p.credentialProvider && !p.githubToken),
+  };
+}

package/yeaft/llm/router.js

@@ -22,7 +22,7 @@
  */
 
 import { LLMAdapter } from './adapter.js';
-import { getThinkingCapability, normalizeEffort } from '../models.js';
+import { getThinkingCapability, normalizeEffort, parseModelRef } from '../models.js';
 import { pairSanitize } from '../pair-sanitize.js';
 
 /**
@@ -106,7 +106,7 @@ export function filterEffortForModel(params) {
     const { effort: _drop, ...rest } = params;
     return rest;
   }
-  const cap = getThinkingCapability(params.model);
+  const cap = getThinkingCapability(parseModelRef(params.model).modelId);
   if (!cap.supportsThinking || cap.thinkingProtocol === 'none') {
     const { effort: _drop, ...rest } = params;
     return rest;
@@ -220,6 +220,10 @@ export class AdapterRouter extends LLMAdapter {
       for (const raw of provider.models) {
         const entry = normalizeModelEntry(raw);
         if (!entry) continue;
+        const ref = provider.name ? `${provider.name}/${entry.id}` : entry.id;
+        if (!this.#modelToProvider.has(ref)) {
+          this.#modelToProvider.set(ref, { provider, entry });
+        }
         if (!this.#modelToProvider.has(entry.id)) {
           this.#modelToProvider.set(entry.id, { provider, entry });
         }
@@ -276,13 +280,13 @@ export class AdapterRouter extends LLMAdapter {
    * Resolve a model ID to its provider's adapter (lazy-created, cached).
    *
    * @param {string} modelId
-   * @returns {Promise<LLMAdapter>}
+   * @returns {Promise<{adapter: LLMAdapter, modelId: string}>}
    */
-  async #resolveAdapter(modelId) {
-    const hit = this.#modelToProvider.get(modelId);
+  async #resolveAdapter(modelRef) {
+    const hit = this.#modelToProvider.get(modelRef);
     if (!hit) {
       throw new Error(
-        `Model "${modelId}" not found in any provider. ` +
+        `Model "${modelRef}" not found in any provider. ` +
         `Available models: ${[...this.#modelToProvider.keys()].join(', ') || '(none)'}. ` +
         `Check your config.json providers[].models arrays.`
       );
@@ -308,7 +312,7 @@ export class AdapterRouter extends LLMAdapter {
     const apiKeyFp = apiKey ? this.#shortFingerprint(apiKey) : 'none';
     const cacheKey = `${provider.name}::${protocol}::${apiKeyFp}`;
     const cached = this.#adapterCache.get(cacheKey);
-    if (cached) return cached;
+    if (cached) return { adapter: cached, modelId: entry.id };
 
     // Token rotation eviction: when a credential provider hands us a NEW
     // fingerprint for the same (provider, protocol) pair, drop the stale
@@ -345,7 +349,7 @@ export class AdapterRouter extends LLMAdapter {
     }
 
     this.#adapterCache.set(cacheKey, adapter);
-    return adapter;
+    return { adapter, modelId: entry.id };
   }
 
   /**
@@ -362,6 +366,11 @@ export class AdapterRouter extends LLMAdapter {
    */
   async #resolveApiKey(provider) {
     const name = provider && provider.credentialProvider;
+    if (name === 'github-copilot' && provider?.githubToken) {
+      const { exchangeToken } = await import('./credentials/github-copilot.js');
+      const exchanged = await exchangeToken(provider.githubToken);
+      return exchanged.token;
+    }
     if (!name) return provider?.apiKey || '';
     const { getCredentialProvider, CREDENTIAL_PROVIDER_NAMES } = await import('./credentials/index.js');
     const cp = getCredentialProvider(name);
@@ -402,8 +411,8 @@ export class AdapterRouter extends LLMAdapter {
   async *stream(params) {
     const filtered = filterEffortForModel(params);
     const sanitized = sanitizeMessagesForWire(filtered);
-    const adapter = await this.#resolveAdapter(sanitized.model);
-    yield* adapter.stream(sanitized);
+    const { adapter, modelId } = await this.#resolveAdapter(sanitized.model);
+    yield* adapter.stream({ ...sanitized, model: modelId });
   }
 
   /**
@@ -415,8 +424,8 @@ export class AdapterRouter extends LLMAdapter {
   async call(params) {
     const filtered = filterEffortForModel(params);
     const sanitized = sanitizeMessagesForWire(filtered);
-    const adapter = await this.#resolveAdapter(sanitized.model);
-    return adapter.call(sanitized);
+    const { adapter, modelId } = await this.#resolveAdapter(sanitized.model);
+    return adapter.call({ ...sanitized, model: modelId });
   }
 
   /**
@@ -437,8 +446,17 @@ export class AdapterRouter extends LLMAdapter {
    */
   listAvailableModels() {
     const result = [];
-    for (const [modelId, hit] of this.#modelToProvider) {
-      result.push({ modelId, providerName: hit.provider.name });
+    const seen = new Set();
+    for (const provider of this.#providers) {
+      if (!Array.isArray(provider.models)) continue;
+      for (const raw of provider.models) {
+        const entry = normalizeModelEntry(raw);
+        if (!entry) continue;
+        const key = `${provider.name}/${entry.id}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        result.push({ modelId: entry.id, providerName: provider.name });
+      }
     }
     return result;
   }

package/yeaft/web-bridge.js

@@ -2725,6 +2725,7 @@ async function ensureSessionLoaded() {
   const yeaftDir = ctx.CONFIG?.yeaftDir;
   session = await loadSession({
     ...(yeaftDir && { dir: yeaftDir }),
+    configOverrides: { globalLlmConfig: ctx.globalLlmConfig || { providers: [] } },
     skipMCP: false,
     skipSkills: false,
     serverMode: true,
@@ -3850,6 +3851,7 @@ export async function handleYeaftLoadHistory(msg) {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     session = await loadSession({
       ...(yeaftDir && { dir: yeaftDir }),
+      configOverrides: { globalLlmConfig: ctx.globalLlmConfig || { providers: [] } },
       skipMCP: false,
       skipSkills: false,
       serverMode: true,
@@ -4165,6 +4167,7 @@ export async function resetYeaftSession() {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     session = await loadSession({
       ...(yeaftDir && { dir: yeaftDir }),
+      configOverrides: { globalLlmConfig: ctx.globalLlmConfig || { providers: [] } },
       skipMCP: false,
       skipSkills: false,
       serverMode: true,