@yeaft/webchat-agent 0.1.945 → 0.1.947

package/cli.js

@@ -7,6 +7,8 @@ import { assertNodeVersion } from './check-node-version.js';
 assertNodeVersion({ component: '@yeaft/webchat-agent' });
 
 import { execSync, spawn } from 'child_process';
+import { createInterface } from 'readline/promises';
+import { stdin as input, stdout as output } from 'process';
 import { readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
@@ -18,6 +20,8 @@ import {
   readLocalLlmConfig,
   removeProvider,
   setLocalModels,
+  useGitHubCopilot,
+  useOpenAICompatible,
   writeLocalLlmConfig,
 } from './llm-config-cli.js';
 
@@ -34,7 +38,7 @@ const SERVICE_COMMANDS = ['install', 'uninstall', 'start', 'stop', 'restart', 's
 if (command === 'doctor') {
   handleDoctorCommand();
 } else if (command === 'llm') {
-  handleLlmCommand(subArgs);
+  await handleLlmCommand(subArgs);
 } else if (command === 'upgrade') {
   upgrade();
 } else if (command === '--version' || command === '-v') {
@@ -93,6 +97,9 @@ function printLlmHelp() {
 
   Usage:
     yeaft-agent llm show [--reveal]
+    yeaft-agent llm setup
+    yeaft-agent llm use github-copilot --model <modelId> [--fast <modelId>] [--allow-unknown-model]
+    yeaft-agent llm use openai-compatible --name <name> --base-url <url> --api-key-env <ENV> --model <modelId> [--fast <modelId>]
     yeaft-agent llm add-provider --name <name> --base-url <url> --models <m1,m2> \
       [--api-key <key>|--api-key-env <ENV>|--credential-provider github-copilot] \
       [--protocol anthropic|openai-responses] [--set-primary <model>] [--set-fast <model>]
@@ -100,24 +107,27 @@ function printLlmHelp() {
     yeaft-agent llm remove-provider --name <name>
 
   Behavior:
+    setup/use are the recommended low-config path; add-provider is the advanced manual path.
+    GitHub Copilot uses the local credential provider and never writes a token to config.
     add-provider updates/replaces an existing provider with the same --name.
     --api-key-env reads the environment variable value and writes it as apiKey.
     set-model requires full provider/model references.
     --config <path> can target a config file for tests or scripted setup.
 
   Examples:
+    yeaft-agent llm setup
+    yeaft-agent llm use github-copilot --model claude-sonnet-4.5 --fast gpt-4.1
     OPENAI_KEY=sk-... yeaft-agent llm add-provider --name openai --base-url https://api.openai.com/v1 --models gpt-5,gpt-4.1 --api-key-env OPENAI_KEY --protocol openai-responses --set-primary gpt-5
-    yeaft-agent llm add-provider --name copilot --base-url https://api.githubcopilot.com --models claude-sonnet-4.5,gpt-5 --credential-provider github-copilot
     yeaft-agent llm set-model --primary openai/gpt-5 --fast openai/gpt-4.1
     yeaft-agent llm show --reveal
 `);
 }
 
-function handleLlmCommand(args) {
+async function handleLlmCommand(args) {
   const subcommand = args[0];
 
   try {
-    const options = parseLlmArgs(args.slice(1));
+    const options = parseLlmArgs(args.slice(subcommand === 'use' ? 2 : 1));
     const configPath = options.config || getDefaultYeaftConfigPath();
     if (!subcommand || subcommand === '--help' || subcommand === '-h' || subcommand === 'help') {
       printLlmHelp();
@@ -132,6 +142,33 @@ function handleLlmCommand(args) {
 
     const current = readLocalLlmConfig(configPath);
     let result;
+    if (subcommand === 'setup') {
+      await runLlmSetup(current, configPath);
+      return;
+    }
+
+    if (subcommand === 'use') {
+      const preset = args[1];
+      if (preset === 'github-copilot') {
+        result = await useGitHubCopilot(current, options);
+        writeLocalLlmConfig(result.config, configPath);
+        console.log(`Configured GitHub Copilot provider with ${result.discovery.models.length} ${result.discovery.source} models.`);
+        if (result.discovery.warning) console.log(`Warning: ${result.discovery.warning}`);
+        console.log(`Primary model: ${result.config.primaryModel}`);
+        if (result.config.fastModel) console.log(`Fast model: ${result.config.fastModel}`);
+        return;
+      }
+      if (preset === 'openai-compatible') {
+        result = await useOpenAICompatible(current, options, process.env);
+        writeLocalLlmConfig(result.config, configPath);
+        console.log(`Configured ${result.provider.name} with ${result.discovery.models.length} live models.`);
+        console.log(`Primary model: ${result.config.primaryModel}`);
+        if (result.config.fastModel) console.log(`Fast model: ${result.config.fastModel}`);
+        return;
+      }
+      throw new Error(`Unsupported llm use preset: ${preset || '(missing)'}`);
+    }
+
     if (subcommand === 'add-provider') {
       result = addOrUpdateProvider(current, options, process.env);
       writeLocalLlmConfig(result.config, configPath);
@@ -167,12 +204,50 @@ function handleLlmCommand(args) {
   }
 }
 
+
+async function runLlmSetup(current, configPath) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error('Interactive setup requires a TTY. Use `yeaft-agent llm use github-copilot --model <modelId>` in scripts.');
+  }
+
+  const rl = createInterface({ input, output });
+  try {
+    console.log('Yeaft LLM setup');
+    console.log('1) GitHub Copilot (uses local device token / gh auth, no API key in config)');
+    console.log('2) Advanced manual provider (use add-provider command)');
+    const choice = (await rl.question('Choose provider [1]: ')).trim() || '1';
+    if (choice !== '1') {
+      console.log('Use `yeaft-agent llm add-provider --help` for advanced endpoints.');
+      return;
+    }
+
+    const discovery = await useGitHubCopilot(current, { model: '__placeholder__', allowUnknownModel: true });
+    const ids = discovery.discovery.models;
+    console.log('\nAvailable GitHub Copilot models:');
+    ids.forEach((id, idx) => console.log(`  ${idx + 1}) ${id}`));
+    const answer = (await rl.question('Primary model number or id: ')).trim();
+    const primary = ids[Number(answer) - 1] || answer;
+    if (!primary) throw new Error('A primary model is required.');
+    const fastAnswer = (await rl.question('Fast model number or id (optional): ')).trim();
+    const fast = fastAnswer ? (ids[Number(fastAnswer) - 1] || fastAnswer) : null;
+    const result = await useGitHubCopilot(current, { model: primary, fast, allowUnknownModel: false });
+    writeLocalLlmConfig(result.config, configPath);
+    console.log(`Configured GitHub Copilot with ${result.discovery.models.length} ${result.discovery.source} models.`);
+    if (result.discovery.warning) console.log(`Warning: ${result.discovery.warning}`);
+    console.log(`Primary model: ${result.config.primaryModel}`);
+    if (result.config.fastModel) console.log(`Fast model: ${result.config.fastModel}`);
+  } finally {
+    rl.close();
+  }
+}
+
 function parseLlmArgs(args) {
   const options = {};
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === '--reveal') {
-      options.reveal = true;
+    if (arg === '--reveal' || arg === '--allow-unknown-model') {
+      const key = arg === '--reveal' ? 'reveal' : 'allowUnknownModel';
+      options[key] = true;
       continue;
     }
     const key = arg.startsWith('--') ? arg.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase()) : null;

package/connection/buffer.js

@@ -41,7 +41,11 @@ export async function sendToServer(msg) {
   }
 
   try {
-    if (ctx.sessionKey) {
+    // feat-ws-plaintext-negotiation: encrypt only when the server has
+    // NOT advertised plaintext acceptance. Defaults to encrypted for
+    // back-compat with old servers; flipped to plaintext when the
+    // `registered` frame includes `acceptPlaintext: true`.
+    if (ctx.serverEncryptionRequired && ctx.sessionKey) {
       const encrypted = await encrypt(msg, ctx.sessionKey);
       ctx.ws.send(JSON.stringify(encrypted));
     } else {

package/connection/index.js

@@ -21,7 +21,17 @@ export function connect() {
     console.log(`Disallowed tools: ${ctx.CONFIG.disallowedTools.join(', ')}`);
   }
 
-  ctx.ws = new WebSocket(url);
+  ctx.ws = new WebSocket(url, {
+    // Match server's permessage-deflate config (bounded memory,
+    // skip compression for small frames). The `ws` library handles
+    // streaming compression so we no longer need the synchronous
+    // gzip-before-encrypt on the hot path.
+    perMessageDeflate: {
+      clientNoContextTakeover: true,
+      serverNoContextTakeover: true,
+      threshold: 1024
+    }
+  });
 
   ctx.ws.on('open', () => {
     console.log('Connected to server, waiting for auth challenge...');

package/connection/message-router.js

@@ -36,6 +36,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getYeaftSettings, updateYeaftSettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../yeaft/config-api.js';
+import { discoverLlmModels } from '../llm-model-discovery.js';
 import { fetchModelsDev } from '../yeaft/llm/models-dev.js';
 import { handleYeaftSessionSend, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, handleYeaftLoadHistory, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListSessions, handleYeaftCreateSession, handleYeaftRenameSession, handleYeaftUpdateSession, handleYeaftUpdateSessionConfig, handleYeaftArchiveSession, handleYeaftDeleteSession, handleYeaftSessionAddMember, handleYeaftSessionRemoveMember, handleYeaftSessionSetDefaultVp, handleYeaftScanWorkdirSessions, handleYeaftRestoreSession, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, handleYeaftMcpList, handleYeaftMcpAdd, handleYeaftMcpRemove, handleYeaftMcpReload, broadcastLanguageChange, broadcastYeaftSessionSnapshotEager } from '../yeaft/web-bridge.js';
 import { startYeaftStatusRefresh, refreshYeaftStatus } from '../yeaft/status-cache.js';
@@ -48,6 +49,15 @@ export async function handleMessage(msg) {
         console.log('Encryption enabled');
       }
 
+      // feat-ws-plaintext-negotiation: new server advertises that it
+      // will accept plaintext frames from us. Stop encrypting outbound.
+      // The receive path (parseMessage) stays unconditional so the old
+      // ciphertext that may already be in flight still decrypts.
+      if (msg.acceptPlaintext === true) {
+        ctx.serverEncryptionRequired = false;
+        console.log('[WS] Server accepts plaintext, disabling outbound encryption');
+      }
+
       // 只保存基本配置（不再保存 agentId，因为现在用 agentName 作为 ID）
       ctx.saveConfig({
         serverUrl: ctx.CONFIG.serverUrl,
@@ -342,6 +352,28 @@ export async function handleMessage(msg) {
       break;
     }
 
+    case 'discover_llm_models': {
+      try {
+        const result = await discoverLlmModels(msg || {});
+        sendToServer({
+          type: 'llm_models_discovered',
+          agentId: msg.agentId,
+          requestId: msg.requestId,
+          providerType: msg.providerType || msg.provider || msg.preset,
+          ...result,
+        });
+      } catch (e) {
+        sendToServer({
+          type: 'llm_models_discovered',
+          agentId: msg.agentId,
+          requestId: msg.requestId,
+          providerType: msg.providerType || msg.provider || msg.preset,
+          error: e.message || String(e),
+        });
+      }
+      break;
+    }
+
     case 'update_llm_config': {
       // Capture the user's intent BEFORE updateLlmConfig — the return
       // envelope ALWAYS populates `language` (falls back to 'en'), so

package/context.js

@@ -4,6 +4,11 @@
 export default {
   ws: null,
   sessionKey: null,
+  // feat-ws-plaintext-negotiation: defaults `true` (= assume old server,
+  // keep encrypting outbound for back-compat). Cleared to `false` when
+  // the agent receives `registered { acceptPlaintext: true }` from a
+  // new server — see message-router.js `case 'registered'`.
+  serverEncryptionRequired: true,
   conversations: new Map(),
   terminals: new Map(),
   proxyPorts: [],

package/index.js

@@ -111,7 +111,11 @@ loadMcpServers();
 
 // Agent capabilities（启动时自动检测）
 async function detectCapabilities() {
-  const capabilities = ['background_tasks', 'file_editor', 'ping_session'];
+  // feat-ws-plaintext-negotiation: `plaintext-ok` advertises that this
+  // agent build can speak plaintext WS frames. New servers see this and
+  // flip `agent.encryptOutbound = false`, stopping outbound encryption
+  // to this peer. Old servers ignore the unknown capability token.
+  const capabilities = ['background_tasks', 'file_editor', 'ping_session', 'plaintext-ok'];
   const pty = await loadNodePty();
   if (pty) capabilities.push('terminal');
 

package/llm-config-cli.js

@@ -1,6 +1,12 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { dirname, join } from 'path';
 import { homedir } from 'os';
+import {
+  discoverGitHubCopilotModels,
+  discoverOpenAICompatibleModels,
+  GITHUB_COPILOT_PROVIDER,
+  modelIdsFromProviderModels,
+} from './llm-model-discovery.js';
 
 const VALID_PROTOCOLS = new Set(['anthropic', 'openai-responses']);
 const VALID_CREDENTIAL_PROVIDERS = new Set(['github-copilot']);
@@ -194,3 +200,86 @@ function validateCredentials(options, env) {
     }
   }
 }
+
+
+export async function useGitHubCopilot(config, options = {}) {
+  const primaryModel = requireNonEmpty(options.model, '--model');
+  const fastModel = options.fast ? String(options.fast).trim() : null;
+  const discovery = await discoverGitHubCopilotModels(options);
+  const discoveredIds = modelIdsFromProviderModels(discovery.providerModels);
+  const allowUnknown = Boolean(options.allowUnknownModel);
+
+  for (const model of [primaryModel, fastModel].filter(Boolean)) {
+    if (!allowUnknown && !discoveredIds.includes(model)) {
+      throw new Error(`Model "${model}" was not found in the GitHub Copilot model catalog. Use --allow-unknown-model to save it anyway.`);
+    }
+  }
+
+  const providerModels = [...discovery.providerModels];
+  if (allowUnknown) {
+    const known = new Set(discoveredIds);
+    for (const model of [primaryModel, fastModel].filter(Boolean)) {
+      if (!known.has(model)) {
+        providerModels.push(model);
+        known.add(model);
+      }
+    }
+  }
+
+  const next = { ...config };
+  const providers = Array.isArray(config.providers) ? [...config.providers] : [];
+  const provider = {
+    ...GITHUB_COPILOT_PROVIDER,
+    models: providerModels,
+  };
+  const index = providers.findIndex(p => p && p.name === provider.name);
+  if (index >= 0) providers[index] = provider;
+  else providers.push(provider);
+
+  next.providers = providers;
+  next.primaryModel = `${provider.name}/${primaryModel}`;
+  if (fastModel) next.fastModel = `${provider.name}/${fastModel}`;
+
+  return { config: next, provider, discovery };
+}
+
+
+export async function useOpenAICompatible(config, options = {}, env = process.env) {
+  const name = options.name ? String(options.name).trim() : 'openai';
+  const baseUrl = requireNonEmpty(options.baseUrl, '--base-url');
+  const primaryModel = requireNonEmpty(options.model, '--model');
+  const fastModel = options.fast ? String(options.fast).trim() : null;
+  validateCredentials(options, env);
+  const apiKey = options.apiKey || env[options.apiKeyEnv];
+  const discovery = await discoverOpenAICompatibleModels({ ...options, apiKey });
+  const discoveredIds = modelIdsFromProviderModels(discovery.providerModels);
+  const allowUnknown = Boolean(options.allowUnknownModel);
+
+  for (const model of [primaryModel, fastModel].filter(Boolean)) {
+    if (!allowUnknown && !discoveredIds.includes(model)) {
+      throw new Error(`Model "${model}" was not found in the provider model catalog. Use --allow-unknown-model to save it anyway.`);
+    }
+  }
+
+  const providerModels = [...discovery.providerModels];
+  if (allowUnknown) {
+    const known = new Set(discoveredIds);
+    for (const model of [primaryModel, fastModel].filter(Boolean)) {
+      if (!known.has(model)) {
+        providerModels.push(model);
+        known.add(model);
+      }
+    }
+  }
+
+  const next = { ...config };
+  const providers = Array.isArray(config.providers) ? [...config.providers] : [];
+  const provider = { name, baseUrl, apiKey, protocol: 'openai-responses', models: providerModels };
+  const index = providers.findIndex(p => p && p.name === provider.name);
+  if (index >= 0) providers[index] = provider;
+  else providers.push(provider);
+  next.providers = providers;
+  next.primaryModel = `${provider.name}/${primaryModel}`;
+  if (fastModel) next.fastModel = `${provider.name}/${fastModel}`;
+  return { config: next, provider, discovery };
+}

package/llm-model-discovery.js

@@ -0,0 +1,169 @@
+import { getApiToken, copilotRequestHeaders } from './yeaft/llm/credentials/github-copilot.js';
+
+export const GITHUB_COPILOT_PROVIDER = {
+  name: 'github-copilot',
+  baseUrl: 'https://api.githubcopilot.com',
+  credentialProvider: 'github-copilot',
+  protocol: 'openai-responses',
+};
+
+export const FALLBACK_GITHUB_COPILOT_MODELS = [
+  'gpt-5.4',
+  'gpt-5.4-mini',
+  'gpt-5-mini',
+  'gpt-5.3-codex',
+  'gpt-5.2-codex',
+  'gpt-4.1',
+  'gpt-4o',
+  'gpt-4o-mini',
+  'claude-opus-4.6',
+  'claude-sonnet-4.6',
+  'claude-sonnet-4.5',
+  'claude-haiku-4.5',
+  'gemini-2.5-pro',
+];
+
+function modelId(item) {
+  if (typeof item === 'string') return item.trim();
+  if (item && typeof item === 'object') return String(item.id || '').trim();
+  return '';
+}
+
+function uniqueIds(items) {
+  const seen = new Set();
+  const ids = [];
+  for (const item of Array.isArray(items) ? items : []) {
+    const id = modelId(item);
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    ids.push(id);
+  }
+  return ids;
+}
+
+export function modelEntryForProvider(id) {
+  const value = String(id || '').trim();
+  if (!value) return null;
+  return value.toLowerCase().startsWith('claude-')
+    ? { id: value, protocol: 'anthropic' }
+    : value;
+}
+
+export function modelIdsFromProviderModels(models) {
+  return uniqueIds(models);
+}
+
+export function providerModelsFromIds(ids) {
+  return uniqueIds(ids).map(modelEntryForProvider).filter(Boolean);
+}
+
+function parseModelPayload(payload) {
+  if (Array.isArray(payload)) return uniqueIds(payload);
+  if (payload && Array.isArray(payload.data)) return uniqueIds(payload.data);
+  if (payload && Array.isArray(payload.models)) return uniqueIds(payload.models);
+  return [];
+}
+
+async function readJson(res) {
+  const text = await res.text();
+  if (!text.trim()) return null;
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    throw new Error(`Invalid JSON model catalog: ${e.message}`);
+  }
+}
+
+function fallbackResult(provider, reason) {
+  return {
+    provider,
+    models: [...FALLBACK_GITHUB_COPILOT_MODELS],
+    providerModels: providerModelsFromIds(FALLBACK_GITHUB_COPILOT_MODELS),
+    source: 'fallback',
+    warning: `Live model catalog unavailable (${reason}); using fallback Copilot model list.`,
+  };
+}
+
+export async function discoverGitHubCopilotModels({ fetchFn = fetch, getTokenFn = getApiToken } = {}) {
+  const tokenInfo = await getTokenFn({ fetchFn });
+  if (!tokenInfo?.token) {
+    const err = new Error('GitHub Copilot credential not found. Run `gh auth login` or complete the Copilot device login first.');
+    err.code = 'COPILOT_CREDENTIAL_MISSING';
+    throw err;
+  }
+
+  try {
+    const res = await fetchFn('https://api.githubcopilot.com/models', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${tokenInfo.token}`,
+        Accept: 'application/json',
+        ...copilotRequestHeaders({ isAgentTurn: true }),
+      },
+    });
+    if (res.status === 401 || res.status === 403) {
+      const err = new Error('GitHub Copilot credential is invalid or lacks Copilot access. Re-authenticate with `gh auth login` or complete the Copilot device login again.');
+      err.code = 'COPILOT_AUTH_INVALID';
+      throw err;
+    }
+    if (!res.ok) return fallbackResult(GITHUB_COPILOT_PROVIDER, `HTTP ${res.status}`);
+    const payload = await readJson(res);
+    const models = parseModelPayload(payload);
+    if (models.length === 0) return fallbackResult(GITHUB_COPILOT_PROVIDER, 'empty catalog');
+    return {
+      provider: GITHUB_COPILOT_PROVIDER,
+      models,
+      providerModels: providerModelsFromIds(models),
+      source: 'live',
+      warning: null,
+    };
+  } catch (e) {
+    if (e?.code === 'COPILOT_AUTH_INVALID') throw e;
+    return fallbackResult(GITHUB_COPILOT_PROVIDER, e.message || String(e));
+  }
+}
+
+export function openAIModelsUrl(baseUrl) {
+  const raw = String(baseUrl || '').trim();
+  if (!raw) throw new Error('OpenAI-compatible discovery requires a base URL.');
+  const url = new URL(raw);
+  const pathname = url.pathname.replace(/\/+$/, '');
+  if (pathname.endsWith('/models')) {
+    url.pathname = pathname;
+  } else if (pathname.endsWith('/v1')) {
+    url.pathname = `${pathname}/models`;
+  } else {
+    url.pathname = `${pathname}/v1/models`;
+  }
+  return url.toString();
+}
+
+export async function discoverOpenAICompatibleModels({ baseUrl, apiKey, fetchFn = fetch } = {}) {
+  if (!apiKey) throw new Error('OpenAI-compatible discovery requires an API key.');
+  const url = openAIModelsUrl(baseUrl);
+  const res = await fetchFn(url, {
+    method: 'GET',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      Accept: 'application/json',
+    },
+  });
+  if (!res.ok) throw new Error(`Model discovery failed: HTTP ${res.status}`);
+  const payload = await readJson(res);
+  const models = parseModelPayload(payload);
+  if (models.length === 0) throw new Error('Model discovery returned no models.');
+  return {
+    provider: { baseUrl, protocol: 'openai-responses' },
+    models,
+    providerModels: providerModelsFromIds(models),
+    source: 'live',
+    warning: null,
+  };
+}
+
+export async function discoverLlmModels(options = {}) {
+  const providerType = options.providerType || options.provider || options.preset;
+  if (providerType === 'github-copilot') return discoverGitHubCopilotModels(options);
+  if (providerType === 'openai-compatible') return discoverOpenAICompatibleModels(options);
+  throw new Error(`Unsupported provider preset: ${providerType || '(missing)'}`);
+}

package/package.json

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