@yeaft/webchat-agent 0.1.860 → 0.1.863

package/connection/message-router.js

@@ -37,7 +37,7 @@ 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 { fetchModelsDev } from '../yeaft/llm/models-dev.js';
-import { handleYeaftGroupChat, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, handleYeaftLoadHistory, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListGroups, handleYeaftCreateGroup, handleYeaftRenameGroup, handleYeaftUpdateGroup, handleYeaftUpdateGroupConfig, handleYeaftArchiveGroup, handleYeaftDeleteGroup, handleYeaftAddMember, handleYeaftRemoveMember, handleYeaftSetDefaultVp, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, broadcastLanguageChange } from '../yeaft/web-bridge.js';
+import { handleYeaftGroupChat, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, handleYeaftLoadHistory, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListGroups, handleYeaftCreateGroup, handleYeaftRenameGroup, handleYeaftUpdateGroup, handleYeaftUpdateGroupConfig, handleYeaftArchiveGroup, handleYeaftDeleteGroup, handleYeaftAddMember, handleYeaftRemoveMember, handleYeaftSetDefaultVp, handleYeaftChatSend, handleYeaftListChats, handleYeaftCreateChat, handleYeaftRenameChat, handleYeaftArchiveChat, handleYeaftDeleteChat, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, broadcastLanguageChange } from '../yeaft/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -547,6 +547,26 @@ export async function handleMessage(msg) {
       handleYeaftSetDefaultVp(msg);
       break;
 
+    // Yeaft Chat Mode (1:1 single-VP) — separate from group fan-out.
+    case 'yeaft_chat_send':
+      await handleYeaftChatSend(msg);
+      break;
+    case 'yeaft_list_chats':
+      await handleYeaftListChats(msg);
+      break;
+    case 'yeaft_create_chat':
+      await handleYeaftCreateChat(msg);
+      break;
+    case 'yeaft_rename_chat':
+      await handleYeaftRenameChat(msg);
+      break;
+    case 'yeaft_archive_chat':
+      await handleYeaftArchiveChat(msg);
+      break;
+    case 'yeaft_delete_chat':
+      await handleYeaftDeleteChat(msg);
+      break;
+
     // wave-6b: manual dream trigger from VP detail page
     case 'yeaft_dream_trigger':
     case 'unify_dream_trigger':

package/conversation.js

@@ -287,6 +287,11 @@ export function parseSlashCommand(message) {
 export async function sendConversationList() {
   const list = [];
   for (const [id, state] of ctx.conversations) {
+    let providerCaps = state.capabilities;
+    if (!providerCaps) {
+      try { providerCaps = getProvider(state.providerName || DEFAULT_PROVIDER).capabilities || null; }
+      catch { providerCaps = null; }
+    }
     const entry = {
       id,
       workDir: state.workDir,
@@ -295,7 +300,8 @@ export async function sendConversationList() {
       processing: !!state.turnActive,
       userId: state.userId,
       username: state.username,
-      provider: state.providerName || DEFAULT_PROVIDER
+      provider: state.providerName || DEFAULT_PROVIDER,
+      capabilities: providerCaps || undefined,
     };
     list.push(entry);
   }
@@ -395,6 +401,9 @@ export async function createConversation(msg) {
     state.disallowedTools = disallowedTools || null;
   }
 
+  let createdCaps = null;
+  try { createdCaps = getProvider(provider).capabilities || null; } catch { /* noop */ }
+
   ctx.sendToServer({
     type: 'conversation_created',
     conversationId,
@@ -402,6 +411,7 @@ export async function createConversation(msg) {
     userId,
     username,
     provider,
+    capabilities: createdCaps || undefined,
     disallowedTools: disallowedTools || null
   });
 
@@ -508,6 +518,9 @@ export async function resumeConversation(msg) {
     state.disallowedTools = disallowedTools || null;
   }
 
+  let resumedCaps = null;
+  try { resumedCaps = getProvider(provider).capabilities || null; } catch { /* noop */ }
+
   ctx.sendToServer({
     type: 'conversation_resumed',
     conversationId,
@@ -516,7 +529,8 @@ export async function resumeConversation(msg) {
     historyMessages,
     userId,
     username,
-    provider
+    provider,
+    capabilities: resumedCaps || undefined
   });
 
   // 立即发送 agent 级别的 MCP servers 列表
@@ -766,6 +780,23 @@ export async function handleUserInput(msg) {
       });
     }
     if (workDir) state.workDir = workDir;
+
+    // /clear for capable providers — reset session in-place without spawning new turn
+    if (slashCommand.type === 'slash' && slashCommand.command === '/clear') {
+      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
+      });
+      return;
+    }
+
     sendOutput(conversationId, { type: 'user', message: { role: 'user', content: prompt } });
     state.turnActive = true;
     sendConversationList();
@@ -931,6 +962,30 @@ export function handleAskUserQuestion(conversationId, input, toolCtx) {
  * 则按 conversationId 查找该 conversation 下唯一的 pending question 并 resolve。
  */
 export function handleAskUserAnswer(msg) {
+  // Provider-driven permission round-trip (e.g. Copilot ACP
+  // session/request_permission): if any registered driver owns this
+  // requestId, route the answer back to its `respondToPermissionRequest`
+  // instead of through the generic AskUserQuestion path. Dispatch by
+  // capability + ownership, not by string prefix, so future providers
+  // (hermes-agent etc.) plug in without touching this code.
+  if (msg.conversationId && msg.requestId) {
+    const state = ctx.conversations.get(msg.conversationId);
+    if (state?.pendingPermissions?.has(msg.requestId)) {
+      try {
+        const driver = getProvider(state.providerName || DEFAULT_PROVIDER);
+        if (typeof driver.respondToPermissionRequest === 'function') {
+          const ans = msg.answers || {};
+          const optionId = typeof ans === 'string' ? ans
+            : ans.optionId || ans.option || Object.values(ans)[0];
+          driver.respondToPermissionRequest(state, msg.requestId, optionId);
+          return;
+        }
+      } catch (err) {
+        console.warn('[AskUser] provider perm routing failed:', err?.message || err);
+      }
+    }
+  }
+
   let pending = ctx.pendingUserQuestions.get(msg.requestId);
   let matchedRequestId = msg.requestId;
 

package/package.json

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

package/providers/acp-client.js

@@ -0,0 +1,135 @@
+/**
+ * Tiny JSON-RPC 2.0 client over stdio for Agent Client Protocol (ACP).
+ *
+ * ACP uses newline-delimited JSON (one JSON object per line on each direction).
+ * This client:
+ *   - sends `request(method, params)` → Promise<result>
+ *   - sends `notify(method, params)` (no response expected)
+ *   - dispatches incoming notifications via onNotification(method, params)
+ *   - dispatches incoming requests (server → client) via onRequest(method, params)
+ *     which must return a value (resolved as result) or throw to send an error
+ *
+ * Designed to be reusable by any ACP-style backend (Copilot today,
+ * hermes-agent later).
+ */
+
+export class AcpClient {
+  /**
+   * @param {object} opts
+   * @param {NodeJS.WritableStream} opts.stdin   process.stdin of the child
+   * @param {NodeJS.ReadableStream} opts.stdout  process.stdout of the child
+   * @param {(method:string, params:any)=>void} [opts.onNotification]
+   * @param {(method:string, params:any)=>Promise<any>|any} [opts.onRequest]
+   * @param {(err:Error)=>void} [opts.onError]   transport-level error sink
+   */
+  constructor({ stdin, stdout, onNotification, onRequest, onError }) {
+    this._stdin = stdin;
+    this._stdout = stdout;
+    this._onNotification = onNotification || (() => {});
+    this._onRequest = onRequest || (() => { throw new Error('no onRequest handler'); });
+    this._onError = onError || (() => {});
+    this._nextId = 1;
+    this._pending = new Map(); // id → { resolve, reject }
+    this._buf = '';
+    this._closed = false;
+
+    stdout.on('data', (chunk) => this._onData(chunk));
+    stdout.on('error', (err) => this._onError(err));
+    stdout.on('close', () => this._handleClose());
+  }
+
+  /** Send a JSONRPC request and await its response. */
+  request(method, params) {
+    if (this._closed) return Promise.reject(new Error('acp client closed'));
+    const id = this._nextId++;
+    const payload = { jsonrpc: '2.0', id, method, params };
+    return new Promise((resolve, reject) => {
+      this._pending.set(id, { resolve, reject });
+      try {
+        this._stdin.write(JSON.stringify(payload) + '\n');
+      } catch (err) {
+        this._pending.delete(id);
+        reject(err);
+      }
+    });
+  }
+
+  /** Send a JSONRPC notification (no id, no response). */
+  notify(method, params) {
+    if (this._closed) return;
+    const payload = { jsonrpc: '2.0', method, params };
+    try { this._stdin.write(JSON.stringify(payload) + '\n'); }
+    catch (err) { this._onError(err); }
+  }
+
+  /** Mark closed; reject all pending requests. */
+  close(reason) {
+    if (this._closed) return;
+    this._closed = true;
+    const err = new Error(reason || 'acp client closed');
+    for (const { reject } of this._pending.values()) {
+      try { reject(err); } catch { /* noop */ }
+    }
+    this._pending.clear();
+  }
+
+  _handleClose() {
+    this.close('child stdout closed');
+  }
+
+  _onData(chunk) {
+    this._buf += chunk.toString('utf8');
+    let idx;
+    while ((idx = this._buf.indexOf('\n')) >= 0) {
+      const line = this._buf.slice(0, idx).trim();
+      this._buf = this._buf.slice(idx + 1);
+      if (!line) continue;
+      let msg;
+      try { msg = JSON.parse(line); }
+      catch (err) { this._onError(new Error(`acp: unparsable line: ${line.slice(0, 200)}`)); continue; }
+      this._dispatch(msg);
+    }
+  }
+
+  _dispatch(msg) {
+    // Response (has id and result/error, no method)
+    if (msg.id != null && (Object.prototype.hasOwnProperty.call(msg, 'result') || Object.prototype.hasOwnProperty.call(msg, 'error'))) {
+      const slot = this._pending.get(msg.id);
+      if (!slot) return; // stale
+      this._pending.delete(msg.id);
+      if (msg.error) slot.reject(Object.assign(new Error(msg.error.message || 'acp error'), { code: msg.error.code, data: msg.error.data }));
+      else slot.resolve(msg.result);
+      return;
+    }
+    // Request from server (has id and method) — synchronous response required
+    if (msg.id != null && typeof msg.method === 'string') {
+      Promise.resolve()
+        .then(() => this._onRequest(msg.method, msg.params))
+        .then((result) => {
+          this._safeWrite({ jsonrpc: '2.0', id: msg.id, result: result === undefined ? null : result });
+        })
+        .catch((err) => {
+          this._safeWrite({
+            jsonrpc: '2.0',
+            id: msg.id,
+            error: { code: err?.code || -32603, message: err?.message || String(err) },
+          });
+        });
+      return;
+    }
+    // Notification (method, no id)
+    if (typeof msg.method === 'string') {
+      try { this._onNotification(msg.method, msg.params); }
+      catch (err) { this._onError(err); }
+      return;
+    }
+    this._onError(new Error('acp: unknown message shape'));
+  }
+
+  _safeWrite(payload) {
+    try { this._stdin.write(JSON.stringify(payload) + '\n'); }
+    catch (err) { this._onError(err); }
+  }
+}
+
+export default AcpClient;

package/providers/base.js

@@ -15,9 +15,16 @@
  *
  * @typedef {Object} ChatProvider
  * @property {string} name
+ * @property {ProviderCapabilities} capabilities
+ *   Static feature flags the provider supports. UI uses these to decide which
+ *   header buttons / panels to show, rather than string-matching provider names.
  * @property {(opts: StartOpts) => Promise<Object>} start
  * @property {(state: Object, prompt: string, opts?: Object) => Promise<void>} sendInput
  * @property {(state: Object) => void} abort
+ * @property {(state: Object) => Promise<void>} [clear]
+ *   Optional. Reset in-flight conversation state (e.g. start a new ACP session
+ *   under the same conversationId). If not provided, the frontend falls back to
+ *   a client-side message wipe only.
  * @property {() => Promise<FolderInfo[]>} listFolders
  *   Return the list of work-directories that this provider has sessions for.
  * @property {(workDir: string) => Promise<SessionInfo[]>} listSessions
@@ -26,6 +33,16 @@
  *   Return the resumable transcript as an array of `claude_output`-compatible
  *   envelopes (the same shape the live stream would have produced).
  *
+ * @typedef {Object} ProviderCapabilities
+ * @property {boolean} [compact]      provider supports /compact (auto + manual)
+ * @property {boolean} [clear]        provider supports in-place /clear
+ * @property {boolean} [expert]       provider supports the expert panel / subagent injection
+ * @property {boolean} [mcp]          provider exposes MCP server toggles per conversation
+ * @property {boolean} [subagents]    provider drives subagent watcher events
+ * @property {boolean} [attachments]  provider accepts file / image attachments in prompts
+ * @property {boolean} [askUser]      provider supports the round-trip ask-user permission prompt
+ * @property {boolean} [modelPicker]  provider supports switching model from the UI
+ *
  * @typedef {Object} StartOpts
  * @property {string} conversationId
  * @property {string} workDir

package/providers/claude-code.js

@@ -10,6 +10,17 @@ import {
 
 export const name = 'claude-code';
 
+export const capabilities = Object.freeze({
+  compact: true,
+  clear: true,
+  expert: true,
+  mcp: true,
+  subagents: true,
+  attachments: true,
+  askUser: true,
+  modelPicker: true,
+});
+
 /**
  * Start (or resume) a Claude Code CLI session.
  * Returns the same state object that startClaudeQuery stores in ctx.conversations.
@@ -81,4 +92,4 @@ export async function loadHistory(workDir, sessionId, limit = 500) {
   return loadSessionHistory(workDir, sessionId, limit);
 }
 
-export default { name, start, sendInput, abort, listFolders, listSessions, loadHistory };
+export default { name, capabilities, start, sendInput, abort, listFolders, listSessions, loadHistory };

package/providers/copilot-models.js

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+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' },
+]);
+
+export const DEFAULT_COPILOT_MODEL = 'claude-sonnet-4.5';