@yeaft/webchat-agent 0.1.863 → 0.1.865

package/connection/message-router.js

@@ -18,7 +18,7 @@ import {
   handleGitStatus, handleGitDiff, handleGitAdd, handleGitReset, handleGitRestore, handleGitCommit, handleGitPush,
   handleFileSearch, handleCreateFile, handleDeleteFiles, handleMoveFiles, handleCopyFiles, handleUploadToDir, handleTransferFiles
 } from '../workbench.js';
-import { handleListHistorySessions, handleListFolders } from '../history.js';
+import { handleListHistorySessions, handleListFolders, handleListModels } from '../history.js';
 import {
   createConversation, resumeConversation, deleteConversation,
   handleRefreshConversation, handleCancelExecution,
@@ -112,6 +112,10 @@ export async function handleMessage(msg) {
       await handleListFolders(msg);
       break;
 
+    case 'list_models':
+      await handleListModels(msg);
+      break;
+
     case 'transfer_files':
       await handleTransferFiles(msg);
       break;

package/history.js

@@ -252,3 +252,32 @@ export async function handleListFolders(msg) {
     });
   }
 }
+
+// 列出指定 provider 下可选 model
+export async function handleListModels(msg) {
+  const { requestId, _requestClientId, provider } = msg;
+  const providerName = provider || DEFAULT_PROVIDER;
+  try {
+    const driver = getProvider(providerName);
+    let models = [];
+    if (typeof driver.listModels === 'function') {
+      models = await driver.listModels();
+    }
+    ctx.sendToServer({
+      type: 'models_list',
+      requestId,
+      _requestClientId,
+      provider: providerName,
+      models: Array.isArray(models) ? models : [],
+    });
+  } catch (e) {
+    ctx.sendToServer({
+      type: 'models_list',
+      requestId,
+      _requestClientId,
+      provider: providerName,
+      models: [],
+      error: e.message,
+    });
+  }
+}

package/package.json

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

package/providers/copilot-models.js

@@ -1,17 +1,131 @@
 /**
- * Hard-coded known Copilot CLI model IDs. The CLI accepts `--model <id>` but
- * doesn't expose a list over ACP today, so we ship a curated set that maps
- * to what `copilot /model` shows in interactive mode. Add to this list as
- * Copilot publishes new models — no other code change required.
+ * Copilot model list.
+ *
+ * The Copilot CLI accepts `--model <id>` and the agent-facing API exposes
+ * `GET https://api.githubcopilot.com/models` — the same endpoint VS Code's
+ * model picker uses. We hit it on demand (cached in-process for 10 min),
+ * filter to picker-enabled chat models, and fall back to a curated static
+ * list if the network call fails (so the UI never shows an empty picker).
+ *
+ * Auth re-uses the existing `agent/yeaft/llm/credentials/github-copilot.js`
+ * credential pipeline — gh CLI / env / persisted OAuth all work; the user
+ * does not need to paste an API key as long as Copilot CLI is logged in.
  */
-export const COPILOT_MODELS = Object.freeze([
-  { id: 'gpt-5', label: 'GPT-5' },
-  { id: 'gpt-5-mini', label: 'GPT-5 Mini' },
-  { id: 'claude-sonnet-4', label: 'Claude Sonnet 4' },
-  { id: 'claude-sonnet-4.5', label: 'Claude Sonnet 4.5' },
-  { id: 'claude-opus-4', label: 'Claude Opus 4' },
-  { id: 'gpt-4o', label: 'GPT-4o' },
-  { id: 'o1', label: 'o1' },
+
+import { getApiToken, copilotRequestHeaders, validateRawToken, resolveRawToken } from '../yeaft/llm/credentials/github-copilot.js';
+import { readFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+
+// Curated fallback — small, but covers the common picks if /models is down or
+// the user has no Copilot auth available yet.
+export const FALLBACK_COPILOT_MODELS = Object.freeze([
+  { id: 'claude-sonnet-4.5',  label: 'Claude Sonnet 4.5', vendor: 'Anthropic' },
+  { id: 'claude-sonnet-4',    label: 'Claude Sonnet 4',   vendor: 'Anthropic' },
+  { id: 'claude-opus-4.1',    label: 'Claude Opus 4.1',   vendor: 'Anthropic' },
+  { id: 'gpt-5',              label: 'GPT-5',             vendor: 'OpenAI'    },
+  { id: 'gpt-5-mini',         label: 'GPT-5 Mini',        vendor: 'OpenAI'    },
+  { id: 'gpt-4.1',            label: 'GPT-4.1',           vendor: 'OpenAI'    },
+  { id: 'gemini-2.5-pro',     label: 'Gemini 2.5 Pro',    vendor: 'Google'    },
 ]);
 
 export const DEFAULT_COPILOT_MODEL = 'claude-sonnet-4.5';
+
+const MODELS_ENDPOINT = 'https://api.githubcopilot.com/models';
+const CACHE_TTL_MS = 10 * 60 * 1000;
+const COPILOT_CLI_CONFIG = join(homedir(), '.copilot', 'config.json');
+
+/**
+ * Last-resort token source: the Copilot CLI itself caches an OAuth token at
+ * ~/.copilot/config.json after `copilot login`. If the standard yeaft
+ * credential pipeline (env / gh CLI / persisted device flow) didn't surface
+ * a token, we re-use the CLI's. Same auth surface — no extra perm needed.
+ */
+async function _resolveCopilotCliToken() {
+  try {
+    const raw = await readFile(COPILOT_CLI_CONFIG, 'utf8');
+    // Copilot CLI's config.json starts with `//` comments. Strip line comments
+    // before JSON.parse — the file otherwise has no string-context `//`.
+    const cleaned = raw.split('\n').filter(l => !l.trim().startsWith('//')).join('\n');
+    const cfg = JSON.parse(cleaned);
+    const tokens = cfg?.copilotTokens && typeof cfg.copilotTokens === 'object' ? cfg.copilotTokens : null;
+    if (!tokens) return null;
+    for (const tok of Object.values(tokens)) {
+      if (typeof tok === 'string' && validateRawToken(tok).valid) return tok;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function _resolveBearerToken() {
+  // The /models endpoint accepts the GitHub OAuth token directly as a Bearer
+  // — no token exchange needed (unlike the chat-completion endpoints). So we
+  // prefer the raw OAuth from the standard yeaft pipeline first, then fall
+  // back to the Copilot CLI's own cached OAuth at ~/.copilot/config.json.
+  try {
+    const raw = await resolveRawToken();
+    if (raw?.token) return raw.token;
+  } catch { /* fall through */ }
+  const cliRaw = await _resolveCopilotCliToken();
+  if (cliRaw) return cliRaw;
+  // Last resort: try exchanged token (works for chat endpoints; may also work
+  // if /models gained that auth path in future).
+  const cred = await getApiToken();
+  return cred?.token || null;
+}
+
+let _cache = null; // { models, fetchedAt }
+let _inflight = null; // dedupes concurrent cold-cache calls
+
+/**
+ * Returns a list of `{id, label, vendor, preview, family}` records,
+ * picker-enabled chat models only. Cached for 10 minutes. Never throws —
+ * falls back to the static list on any error (including network timeout).
+ */
+export async function listCopilotModels({ force = false } = {}) {
+  if (!force && _cache && Date.now() - _cache.fetchedAt < CACHE_TTL_MS) {
+    return _cache.models.slice();
+  }
+  if (_inflight) return (await _inflight).slice();
+  _inflight = (async () => {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 5000);
+    try {
+      const token = await _resolveBearerToken();
+      if (!token) return FALLBACK_COPILOT_MODELS.slice();
+      const res = await fetch(MODELS_ENDPOINT, {
+        signal: ac.signal,
+        headers: { ...copilotRequestHeaders({ isAgentTurn: false }), Authorization: `Bearer ${token}` },
+      });
+      if (!res.ok) return FALLBACK_COPILOT_MODELS.slice();
+      const body = await res.json();
+      const data = Array.isArray(body?.data) ? body.data : [];
+      const models = data
+        .filter(m => m && m.model_picker_enabled && m.capabilities?.type === 'chat')
+        .map(m => ({
+          id: m.id,
+          label: m.name || m.id,
+          vendor: m.vendor || '',
+          preview: !!m.preview,
+          family: m.capabilities?.family || '',
+        }));
+      if (!models.length) return FALLBACK_COPILOT_MODELS.slice();
+      _cache = { models, fetchedAt: Date.now() };
+      return models.slice();
+    } catch {
+      return FALLBACK_COPILOT_MODELS.slice();
+    } finally {
+      clearTimeout(timer);
+    }
+  })();
+  try {
+    return (await _inflight).slice();
+  } finally {
+    _inflight = null;
+  }
+}
+
+/** Tests only. */
+export function _resetCopilotModelsCacheForTests() { _cache = null; _inflight = null; }

package/providers/copilot.js

@@ -6,7 +6,7 @@ import { join } from 'path';
 import { DatabaseSync } from 'node:sqlite';
 import ctx from '../context.js';
 import { AcpClient } from './acp-client.js';
-import { COPILOT_MODELS, DEFAULT_COPILOT_MODEL } from './copilot-models.js';
+import { listCopilotModels, DEFAULT_COPILOT_MODEL } from './copilot-models.js';
 
 export const name = 'copilot';
 
@@ -582,9 +582,12 @@ function _knownCopilotTools() {
   ];
 }
 
-/** Exported for the model picker UI. */
-export function listModels() {
-  return COPILOT_MODELS.slice();
+/**
+ * Exported for the model picker UI. Async — hits Copilot's /models endpoint
+ * (cached) and falls back to a static list if auth/network fails.
+ */
+export async function listModels() {
+  return await listCopilotModels();
 }
 
 export default { name, capabilities, start, sendInput, abort, clear, listFolders, listSessions, loadHistory, listModels, respondToPermissionRequest };

package/yeaft/web-bridge.js

@@ -1717,6 +1717,32 @@ function chatErrorPayload(err) {
   };
 }
 
+/**
+ * Build the vpPersona payload threaded into engine.query so the worker
+ * system prompt carries the VP's identity/role/persona/planInstruction.
+ * Returns null on miss — callers treat that as "use generic prompt".
+ * Shared by handleYeaftChatSend and the group fan-out path so the field
+ * set stays in lockstep.
+ */
+function buildVpPersona(vpId) {
+  if (!vpId) return null;
+  try {
+    const vp = readVp(vpId);
+    if (!vp) return null;
+    return {
+      vpId,
+      displayName: vp.displayName || vpId,
+      displayNameZh: vp.displayNameZh || '',
+      role: vp.role || '',
+      roleZh: vp.roleZh || '',
+      persona: vp.persona || '',
+      planInstruction: typeof vp.planInstruction === 'string' ? vp.planInstruction : '',
+    };
+  } catch {
+    return null;
+  }
+}
+
 export function handleYeaftListChats(msg) {
   const requestId = msg && msg.requestId;
   try {
@@ -1729,19 +1755,34 @@ export function handleYeaftListChats(msg) {
 
 export function handleYeaftCreateChat(msg) {
   const requestId = msg && msg.requestId;
+  // Accept fields at top-level (current wire shape) AND inside `payload`
+  // (legacy / future) — keeps backwards compatibility cheap.
+  const top = msg || {};
   const payload = (msg && msg.payload) || {};
+  const displayName = payload.displayName || top.displayName;
+  const workDir = payload.workDir || top.workDir;
+  const explicitId = payload.id || top.id;
+  // Chat mode is 1:1 with the built-in Omni assistant by default. The
+  // VP picker is gone from the UI; callers may still override vpId to
+  // bind a chat to a specialist, but the default is omni.
+  const vpId = payload.vpId || top.vpId || 'omni';
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     if (!yeaftDir) throw new Error('no yeaft directory configured');
-    if (!payload.vpId) throw new Error('vpId required');
+    // Fail loud at create time if the requested VP (default: omni) is
+    // not installed — otherwise the chat would silently degrade to a
+    // generic prompt at first send.
+    if (!buildVpPersona(vpId)) {
+      throw new Error(`VP '${vpId}' is not installed`);
+    }
     const root = chatsRootFor(yeaftDir);
-    const chatId = (payload.id && String(payload.id).trim())
+    const chatId = (explicitId && String(explicitId).trim())
       || `chat_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
     const h = createChatStore(root, {
       id: chatId,
-      vpId: payload.vpId,
-      displayName: payload.displayName,
-      workDir: payload.workDir,
+      vpId,
+      displayName,
+      workDir,
     });
     const meta = h.getMeta();
     h.close();
@@ -1954,6 +1995,11 @@ export async function handleYeaftChatSend(msg) {
       appendedUserPrompts,
     };
 
+    // Load the VP persona (defaults to omni) so the engine's worker
+    // prompt has the right identity/role/persona blocks. Without this,
+    // chat mode runs with a generic system prompt instead of Omni.
+    const vpPersona = buildVpPersona(vpId);
+
     for await (const event of eng.query({
       prompt: text,
       promptParts: attachmentBundle.promptParts && attachmentBundle.promptParts.length > 0 ? attachmentBundle.promptParts : null,
@@ -1961,6 +2007,7 @@ export async function handleYeaftChatSend(msg) {
       userAlreadyPersisted: false,
       threadId: 'main',
       senderVpId: vpId,
+      vpPersona,
     })) {
       resetQueryTimer();
       handleEngineEvent(event, handlerCtx);
@@ -2760,23 +2807,8 @@ export function buildVpQueryOpts({ vpId, groupCoordinator, groupId, envelope, th
   if (groupMeta && typeof groupMeta.workDir === 'string' && groupMeta.workDir.trim()) {
     out.workDir = groupMeta.workDir.trim();
   }
-  try {
-    const vp = readVp(resolvedVpId);
-    if (vp) {
-      out.vpPersona = {
-        vpId: resolvedVpId,
-        displayName: vp.displayName || resolvedVpId,
-        displayNameZh: vp.displayNameZh || '',
-        role: vp.role || '',
-        roleZh: vp.roleZh || '',
-        persona: vp.persona || '',
-        // Optional per-VP planning style for the `StartPlan` tool. Empty
-        // string means "fall back to the default template" — the tool
-        // handles the lookup so callers stay ignorant of the default.
-        planInstruction: typeof vp.planInstruction === 'string' ? vp.planInstruction : '',
-      };
-    }
-  } catch { /* persona load is best-effort */ }
+  const persona = buildVpPersona(resolvedVpId);
+  if (persona) out.vpPersona = persona;
   if (groupCoordinator && typeof groupCoordinator.ingest === 'function') {
     try {
       out.router = createRouter({ coordinator: groupCoordinator });