@yeaft/webchat-agent 1.0.582 → 1.0.584

package/connection/message-router.js

@@ -33,6 +33,7 @@ import { fetchModelsDev } from '../yeaft/llm/models-dev.js';
 import { handleYeaftSessionSend, handleYeaftAskUserAnswer, handleYeaftSubAgentPrompt, handleYeaftTaskCancel, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, refreshLiveSessionConfig, handleYeaftLoadHistory, handleYeaftLoadHistoryOutline, handleYeaftSearchHistory, handleYeaftLoadHistoryWindow, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListSessions, handleYeaftProjectContextSync, handleYeaftProjectMutation, handleYeaftCreateSession, handleYeaftCopySession, handleYeaftRenameSession, handleYeaftUpdateSession, handleYeaftUpdateSessionConfig, handleYeaftArchiveSession, handleYeaftDeleteSession, handleYeaftSessionAddMember, handleYeaftSessionRemoveMember, handleYeaftSessionSetDefaultVp, handleYeaftScanWorkdirSessions, handleYeaftRestoreSession, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, handleYeaftMcpList, handleYeaftMcpAdd, handleYeaftMcpRemove, handleYeaftMcpReload, handleYeaftPluginCatalog, handleYeaftManagedSkill, ensureSessionLoaded, broadcastLanguageChange, broadcastYeaftSessionSnapshotEager, broadcastYeaftVpSnapshotEager, preloadYeaftSkillSlashCommands } from '../yeaft/web-bridge.js';
 import { startYeaftStatusRefresh, forceRefreshYeaftStatus } from '../yeaft/status-cache.js';
 import { handleWorkCenterRequest } from '../yeaft/work-center/bridge.js';
+import { handlePersonRequest } from '../yeaft/person/bridge.js';
 import { handleBrowserRuntimeMessage } from '../browser-runtime/messages.js';
 
 export async function applyLlmConfigUpdate(msg, dependencies = {}) {
@@ -873,6 +874,10 @@ export async function handleMessage(msg) {
       await handleYeaftFetchDebugHistory(msg);
       break;
 
+    case 'person_request':
+      await handlePersonRequest(msg);
+      break;
+
     case 'work_center_request':
       if (ctx.CONFIG?.workCenterEnabled === true) {
         await handleWorkCenterRequest(msg);

package/index.js

@@ -179,7 +179,7 @@ async function detectCapabilities() {
   // 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', 'workbench_session_routes', 'workbench_request_correlation', 'workbench_terminal_cleanup_fence', 'workbench_file_content_chunks', 'workbench_video_stream', 'session_history_search', 'session_history_outline', 'session_history_window_prefetch', 'session_fork_from_turn', 'file_reference_resolution', 'response_image_preview', 'yeaft_plugins', 'yeaft_managed_skills', 'settings_request_correlation', 'work_center_feature_settings'];
-  capabilities.push(getAgentUpgradeCapability());
+  capabilities.push('digital_person', getAgentUpgradeCapability());
   if (ctx.CONFIG?.workCenterEnabled === true) {
     capabilities.push('work_center', 'work_center_message_v2', 'work_center_workbench');
     if (supportsWorkItemAttachments()) capabilities.push('work_item_attachments');
@@ -401,6 +401,10 @@ function cleanup() {
       const { shutdownWorkCenter } = await import('./yeaft/work-center/bridge.js');
       await shutdownWorkCenter();
     } catch {}
+    try {
+      const { shutdownPerson } = await import('./yeaft/person/bridge.js');
+      await shutdownPerson();
+    } catch {}
     try { await shutdownBrowserRuntime(); } catch {}
     if (ctx.ws) ctx.ws.close();
   });

package/local-runtime/server/handlers/client-person.js

@@ -0,0 +1,115 @@
+import { randomUUID } from 'node:crypto';
+import { CONFIG } from '../config.js';
+import { agents } from '../context.js';
+import { forwardToAgent, resolveAgentAccessError, sendToWebClient } from '../ws-utils.js';
+
+const FIELDS = Object.freeze({
+  status: [], open: [], snapshot: [],
+  send: ['text', 'clientMessageId'], think: ['text', 'clientMessageId'],
+  dream: ['clientMessageId'], cancel: ['episodeId'],
+  messages: ['cursor', 'limit'], traces: ['cursor', 'limit'],
+  settings: ['autonomyEnabled'],
+});
+
+/** Request-only relay: identity is supplied by the authenticated Server, never the browser.
+ * Person data stays on the Agent. No Person response is broadcast to other clients.
+ */
+export function createPersonRelay({
+  agentMap = agents, send = sendToWebClient, forward = forwardToAgent,
+  accessError = resolveAgentAccessError, skipAuth = () => CONFIG.skipAuth,
+  timeoutMs = 30_000,
+} = {}) {
+  const pending = new Map();
+  function forget(id) {
+    const row = pending.get(id);
+    if (row) clearTimeout(row.timer);
+    pending.delete(id);
+    return row;
+  }
+  async function reply(client, envelope, value) {
+    await send(client, { type: 'person_response', ...envelope, ...value });
+  }
+  return {
+    async request(client, msg) {
+      if (msg?.type !== 'person_request') return false;
+      const agentId = typeof msg.agentId === 'string' ? msg.agentId : '';
+      const requestId = typeof msg.requestId === 'string' && msg.requestId.length <= 128 ? msg.requestId : null;
+      const op = typeof msg.op === 'string' ? msg.op : '';
+      const envelope = { agentId, requestId, op };
+      const error = !client.authenticated ? 'Authentication required'
+        : accessError(agentId, client.userId, client.role);
+      if (error) {
+        await reply(client, envelope, { ok: false, error });
+        return true;
+      }
+      const ownerId = client.userId || (skipAuth() ? 'local-development' : null);
+      if (!ownerId || !requestId || !Object.hasOwn(FIELDS, op)) {
+        await reply(client, envelope, { ok: false, error: 'Invalid digital person request' });
+        return true;
+      }
+      const agent = agentMap.get(agentId);
+      if (!agent?.capabilities?.includes('digital_person')) {
+        await reply(client, envelope, { ok: false, error: 'This Agent does not support digital persons; upgrade it first' });
+        return true;
+      }
+      if (pending.size >= 1024 || [...pending.values()].filter(row => row.client === client).length >= 32) {
+        await reply(client, envelope, { ok: false, error: 'Too many pending digital person requests' });
+        return true;
+      }
+      const source = msg.payload;
+      if (source != null && (typeof source !== 'object' || Array.isArray(source))) {
+        await reply(client, envelope, { ok: false, error: 'Invalid digital person payload' });
+        return true;
+      }
+      const payload = Object.fromEntries(FIELDS[op].filter(key => Object.hasOwn(source || {}, key)).map(key => [key, source[key]]));
+      if (JSON.stringify(payload).length > 40_000) {
+        await reply(client, envelope, { ok: false, error: 'Digital person input is too large' });
+        return true;
+      }
+      const relayId = randomUUID();
+      const row = { client, agent, ownerId, agentId, envelope };
+      row.timer = setTimeout(() => {
+        if (!forget(relayId)) return;
+        void reply(client, envelope, { ok: false, errorCode: 'timeout', error: 'Digital person request timed out; refresh before retrying' }).catch(() => {});
+      }, timeoutMs);
+      row.timer.unref?.();
+      pending.set(relayId, row);
+      try {
+        const sent = await forward(agentId, {
+          type: 'person_request', requestId: relayId, op, payload,
+          // Only server-authenticated identity crosses the relay boundary.
+          ownerId,
+        });
+        if (sent === false && forget(relayId)) await reply(client, envelope, { ok: false, errorCode: 'offline', error: 'Agent is offline; refresh before retrying' });
+      } catch {
+        // A thrown transport error does not prove the request was never delivered.
+        if (forget(relayId)) await reply(client, envelope, { ok: false, errorCode: 'outcome_unknown', error: 'Agent delivery could not be confirmed; refresh before retrying' });
+      }
+      return true;
+    },
+    async response(agentId, msg) {
+      if (msg?.type !== 'person_response') return false;
+      const row = pending.get(msg.requestId);
+      if (!row || row.agentId !== agentId || row.agent !== agentMap.get(agentId)) return true;
+      forget(msg.requestId);
+      if (!row.client.authenticated || (row.client.userId || (skipAuth() ? 'local-development' : null)) !== row.ownerId
+        || accessError(agentId, row.client.userId, row.client.role)) return true;
+      // Whitelist the response. Echoed owner/agent/op/correlation fields are not trusted.
+      await reply(row.client, row.envelope, msg.ok === true
+        ? { ok: true, data: msg.data }
+        : { ok: false,
+          errorCode: ['outcome_unknown', 'invalid_request', 'busy', 'unsupported', 'not_configured', 'not_open', 'stale', 'idempotency_conflict'].includes(msg.errorCode) ? msg.errorCode : 'requestFailed',
+          error: typeof msg.error === 'string' ? msg.error.slice(0, 500) : 'Digital person request failed' });
+      return true;
+    },
+    clearClient(client) {
+      for (const [id, row] of pending) if (row.client === client) forget(id);
+    },
+    close() { for (const id of pending.keys()) forget(id); },
+  };
+}
+
+const relay = createPersonRelay();
+export const handleClientPerson = (client, msg) => relay.request(client, msg);
+export const handleAgentPerson = (agentId, msg) => relay.response(agentId, msg);
+export const clearPersonRequestsForClient = client => relay.clearClient(client);

package/local-runtime/server/ws-agent.js

@@ -12,6 +12,7 @@ import {
 import { handleAgentConversation } from './handlers/agent-conversation.js';
 import { handleAgentOutput } from './handlers/agent-output.js';
 import { handleAgentWorkCenter } from './handlers/agent-work-center.js';
+import { handleAgentPerson } from './handlers/client-person.js';
 import { handleAgentFileTerminal } from './handlers/agent-file-terminal.js';
 import { handleAgentSync } from './handlers/agent-sync.js';
 import { recordPerfTraceEvent } from './perf-trace.js';
@@ -474,6 +475,7 @@ async function handleAgentMessage(agentId, msg, ws) {
   if (await handleAgentConversation(agentId, agent, msg)) return;
   if (await handleAgentBrowser(agentId, agent, msg)) return;
   if (await handleAgentWorkCenter(agentId, msg)) return;
+  if (await handleAgentPerson(agentId, msg)) return;
   if (await handleAgentOutput(agentId, agent, msg)) return;
   if (await handleAgentFileTerminal(agentId, agent, msg)) return;
   if (await handleAgentSync(agentId, agent, msg)) return;

package/local-runtime/server/ws-client.js

@@ -33,6 +33,7 @@ import { handleClientWorkbench } from './handlers/client-workbench.js';
 import { CLIENT_BROWSER_TYPES, handleClientBrowser } from './handlers/client-browser.js';
 import { handleClientMisc } from './handlers/client-misc.js';
 import { clearWorkCenterRequestsForClient, handleClientWorkCenter } from './handlers/client-work-center.js';
+import { clearPersonRequestsForClient, handleClientPerson } from './handlers/client-person.js';
 import { recordPerfTraceEvent } from './perf-trace.js';
 
 export function cleanupWorkbenchForDisconnectedClient(clientId) {
@@ -201,6 +202,7 @@ export function handleWebConnection(ws, url, req = {}) {
       }
     }
     clearWorkCenterRequestsForClient(client);
+    clearPersonRequestsForClient(client);
     clearAgentSettingsRequestsForClient(clientId);
     clearYeaftDebugRequestsForClient(clientId);
     const browserPeers = clearBrowserRuntimeForClient(client);
@@ -295,5 +297,6 @@ async function handleWebMessage(clientId, msg) {
   if (await handleClientBrowser(client, msg, checkAgentAccess)) return;
   if (await handleClientWorkbench(clientId, client, msg, checkAgentAccess)) return;
   if (await handleClientWorkCenter(client, msg, checkAgentAccess)) return;
+  if (await handleClientPerson(client, msg)) return;
   if (await handleClientMisc(clientId, client, msg, checkAgentAccess)) return;
 }

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.582"}
+{"version":"1.0.584"}