@yeaft/webchat-agent 1.0.289 → 1.0.290

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.289"}
+{"version":"1.0.290"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.289",
+  "version": "1.0.290",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/cli-session-runner.js

@@ -0,0 +1,213 @@
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { Engine } from './engine.js';
+import { createRouter } from './routing/router.js';
+import { createCoordinator } from './sessions/coordinator.js';
+import { sessionsRoot } from './sessions/session-crud.js';
+import { openSession, loadSessionMeta } from './sessions/session-store.js';
+import { loadSessionConfig, resolveSessionConfig } from './sessions/session-config.js';
+import { readVp } from './vp/vp-crud.js';
+import { COLLAB_TOOL_POLICY } from './tools/registry.js';
+
+function buildVpPersona(vpId, loaded) {
+  const vp = readVp(vpId, { libDir: join(loaded.yeaftDir, 'virtual-persons') });
+  if (!vp) return null;
+  return {
+    vpId,
+    displayName: vp.displayName || vpId,
+    displayNameZh: vp.displayNameZh || '',
+    role: vp.role || '',
+    roleZh: vp.roleZh || '',
+    persona: vp.persona || '',
+    planInstruction: vp.planInstruction || '',
+  };
+}
+
+function createEngine(loaded, sessionId, vpId) {
+  const effectiveConfig = resolveSessionConfig(
+    loaded.config,
+    loadSessionConfig(loaded.yeaftDir, sessionId),
+  );
+  return new Engine({
+    adapter: loaded.adapter,
+    trace: loaded.trace,
+    config: effectiveConfig,
+    conversationStore: loaded.conversationStore,
+    memoryIndex: loaded.memoryIndex || null,
+    amsRegistry: loaded.amsRegistry || null,
+    toolRegistry: loaded.toolRegistry,
+    skillManager: loaded.skillManager,
+    mcpManager: loaded.mcpManager,
+    yeaftDir: loaded.yeaftDir,
+    toolStats: loaded.toolStats || null,
+    taskManager: loaded.taskManager || null,
+    sessionId,
+    vpId,
+  });
+}
+
+/**
+ * Open a transport-neutral multi-VP runtime for an existing Yeaft Session.
+ * Different VPs run concurrently; each VP owns one serial promise tail and
+ * one Engine, matching the WebSocket runtime's state-isolation rule.
+ *
+ * Returns null when session metadata does not exist so legacy one-engine CLI
+ * invocations can keep their existing behavior.
+ */
+export function createCliSessionRunner({
+  loaded,
+  sessionId,
+  workDir = process.cwd(),
+  engineFactory = createEngine,
+  personaFactory = buildVpPersona,
+} = {}) {
+  if (!loaded || !sessionId) return null;
+  const sessionDir = join(sessionsRoot(loaded.yeaftDir), sessionId);
+  if (!loadSessionMeta(sessionDir)) return null;
+
+  const handle = openSession(sessionsRoot(loaded.yeaftDir), sessionId);
+  const engines = new Map();
+  const tails = new Map();
+  const pending = new Set();
+  let closed = false;
+
+  const engineFor = (vpId) => {
+    let engine = engines.get(vpId);
+    if (!engine) {
+      engine = engineFactory(loaded, sessionId, vpId);
+      engines.set(vpId, engine);
+    }
+    return engine;
+  };
+
+  let coordinator;
+
+  const runEnvelope = async (vpId, envelope, options) => {
+    const meta = handle.getMeta();
+    const engine = engineFor(vpId);
+    const promptText = envelope?.msg?.text || '';
+    const prompt = `@vp-${vpId} ${promptText}`;
+    const messages = loaded.conversationStore.loadSessionHistoryForVp(sessionId, vpId);
+    const todos = [];
+    let resultText = '';
+    let failed = null;
+    const scopedCoordinator = {
+      group: coordinator.group,
+      ingest(input, opts) {
+        return coordinator.ingest({ ...input, _cliTurnContext: envelope._cliTurnContext }, opts);
+      },
+    };
+    const queryOptions = {
+      prompt,
+      messages,
+      sessionId,
+      workDir: meta.workDir || workDir,
+      senderVpId: vpId,
+      sessionMembers: meta.roster.slice(),
+      sessionAnnouncement: meta.announcement || '',
+      vpPersona: personaFactory(vpId, loaded),
+      router: createRouter({ coordinator: scopedCoordinator }),
+      inboundEnvelope: envelope,
+      userAlreadyPersisted: true,
+      threadId: 'main',
+      vpTurnId: envelope?.msg?.id || randomUUID(),
+      collabToolPolicy: meta.roster.length > 1
+        ? COLLAB_TOOL_POLICY.MULTI_VP
+        : COLLAB_TOOL_POLICY.SINGLE_VP,
+      getCurrentTodos: () => todos.slice(),
+      setCurrentTodos: (next) => {
+        todos.splice(0, todos.length, ...(Array.isArray(next) ? next : []));
+      },
+      askUser: options.askUser
+        ? request => options.askUser(request, vpId, queryOptions.vpTurnId)
+        : null,
+      userEffort: options.modelEffort || null,
+    };
+
+    try {
+      for await (const event of engine.query(queryOptions)) {
+        if (event.type === 'text_delta') resultText += event.text || '';
+        await options.onEvent?.({ vpId, event, sessionId, turnId: queryOptions.vpTurnId });
+      }
+    } catch (error) {
+      failed = error;
+      await options.onEvent?.({
+        vpId,
+        sessionId,
+        turnId: queryOptions.vpTurnId,
+        event: { type: 'error', error, retryable: false },
+      });
+    }
+    return { vpId, result: resultText, error: failed };
+  };
+
+  const enqueue = (vpId, envelope) => {
+    if (closed) throw new Error('CLI Session runner is closed');
+    const turnContext = envelope?._cliTurnContext;
+    if (!turnContext) throw new Error('CLI Session envelope is missing its turn context');
+    const previous = tails.get(vpId) || Promise.resolve();
+    const task = previous.catch(() => {}).then(() => runEnvelope(vpId, envelope, turnContext.options));
+    tails.set(vpId, task);
+    pending.add(task);
+    turnContext.pending.add(task);
+    task.finally(() => {
+      pending.delete(task);
+      turnContext.pending.delete(task);
+      if (tails.get(vpId) === task) tails.delete(vpId);
+    }).catch(() => {});
+    return task;
+  };
+
+  coordinator = createCoordinator(handle, { deliver: enqueue });
+
+  async function drain(tasks = pending) {
+    const results = [];
+    while (tasks.size > 0) {
+      const batch = Array.from(tasks);
+      results.push(...await Promise.all(batch));
+      await Promise.resolve();
+    }
+    return results;
+  }
+
+  return {
+    sessionId,
+    get meta() { return handle.getMeta(); },
+    async run(prompt, options = {}) {
+      if (closed) throw new Error('CLI Session runner is closed');
+      const turnContext = Object.freeze({ options: Object.freeze({ ...options }), pending: new Set() });
+      const messageId = randomUUID();
+      // The shared user row is the durability boundary. Every VP Engine skips
+      // its own user append, preventing @all from duplicating the prompt N times.
+      loaded.conversationStore.append({
+        role: 'user',
+        content: prompt,
+        sessionId,
+        threadId: 'main',
+        clientMessageId: messageId,
+        userAuthored: true,
+      });
+      const report = coordinator.ingest({
+        id: messageId,
+        from: 'user',
+        role: 'user',
+        text: prompt,
+        _cliTurnContext: turnContext,
+      });
+      const results = await drain(turnContext.pending);
+      return { report, results };
+    },
+    abort(reason = 'user') {
+      let count = 0;
+      for (const engine of engines.values()) {
+        if (engine.abort?.(reason)) count += 1;
+      }
+      return count;
+    },
+    async close() {
+      closed = true;
+      await drain();
+      handle.close();
+    },
+  };
+}

package/yeaft/cli.js

@@ -38,7 +38,8 @@ import { ConversationStore } from './conversation/persist.js';
 import { snapshotSessions } from './sessions/session-crud.js';
 import { loadSessionConfig, resolveSessionConfig } from './sessions/session-config.js';
 import { validateSessionId } from './sessions/ids.js';
-import { createJsonlWriter, JsonlInput, runStreamTurn } from './stdio-protocol.js';
+import { createJsonlWriter, JsonlInput, runStreamTurn, runStreamSessionTurn } from './stdio-protocol.js';
+import { createCliSessionRunner } from './cli-session-runner.js';
 
 // ─── Argument parsing ──────────────────────────────────────────
 
@@ -333,16 +334,28 @@ function handleDeleteGroup(config, sessionId) {
 // ─── REPL ──────────────────────────────────────────────────────
 
 async function runREPL(config, args) {
-  // Use loadSession() to wire all subsystems
+  const workDir = resolve(args.workDir || process.cwd());
+  const persisted = args.sessionId ? loadSessionConfig(config.dir, args.sessionId) : {};
+  const effectiveConfig = resolveSessionConfig(config, persisted);
   const session = await loadSession({
-    model: args.model || config.model,
-    language: args.language || config.language,
-    debug: args.debug || config.debug,
+    dir: config.dir,
+    workDir,
+    model: args.model || effectiveConfig.model,
+    language: args.language || effectiveConfig.language,
+    debug: args.debug || effectiveConfig.debug,
     skipMCP: args.skipMCP,
     skipSkills: args.skipSkills,
+    configOverrides: effectiveConfig,
   });
 
   const { engine, conversationStore, trace, skillManager, mcpManager, toolRegistry } = session;
+  const sessionRunner = args.sessionId
+    ? createCliSessionRunner({ loaded: session, sessionId: args.sessionId, workDir })
+    : null;
+  if (args.sessionId && !sessionRunner) {
+    await session.shutdown();
+    throw new Error(`Session not found: ${args.sessionId}`);
+  }
 
   // Load persisted conversation as initial messages. `loadRecent` is now
   // turn-based (one user round-trip = one turn; multi-VP fan-out collapses
@@ -655,9 +668,28 @@ async function runREPL(config, args) {
       return;
     }
 
-    // Regular input → engine.query
+    // Regular input → Session fan-out or legacy single Engine.
     try {
       let responseText = '';
+      if (sessionRunner) {
+        const outcome = await sessionRunner.run(input, {
+          modelEffort: args.modelEffort || session.config.modelEffort || null,
+          onEvent: ({ vpId, event }) => {
+            if (event.type === 'text_delta') {
+              responseText += event.text || '';
+              process.stdout.write(`\n[${vpId}] ${event.text || ''}`);
+            } else if (event.type === 'tool_start') {
+              process.stderr.write(`\n[${vpId}] ${event.name}...\n`);
+            } else if (event.type === 'error') {
+              process.stderr.write(`\n[${vpId}] Error: ${event.error?.message || event.error}\n`);
+            }
+          },
+        });
+        console.log();
+        if (outcome.results.some(result => result.error)) process.exitCode = 1;
+        rl.prompt();
+        return;
+      }
 
       for await (const event of engine.query({
         prompt: input,
@@ -721,6 +753,7 @@ async function runREPL(config, args) {
   });
 
   rl.on('close', async () => {
+    await sessionRunner?.close();
     await session.shutdown();
     console.log('\nBye!');
     process.exit(0);
@@ -766,6 +799,7 @@ async function runStreamJson(config, args) {
     },
   });
   const { engine, conversationStore, skillManager, toolRegistry } = loaded;
+  const sessionRunner = createCliSessionRunner({ loaded, sessionId, workDir });
   const todoState = { value: [] };
 
   write({
@@ -788,8 +822,7 @@ async function runStreamJson(config, args) {
       ...(message.toolCallId && { toolCallId: message.toolCallId }),
       ...(message.toolCalls && { toolCalls: message.toolCalls }),
     }));
-    return runStreamTurn({
-      engine,
+    const turnOptions = {
       prompt,
       messages: priorMessages,
       sessionId,
@@ -800,7 +833,10 @@ async function runStreamJson(config, args) {
       write,
       getCurrentTodos: () => todoState.value.slice(),
       setCurrentTodos: todos => { todoState.value = Array.isArray(todos) ? todos.slice() : []; },
-    });
+    };
+    return sessionRunner
+      ? runStreamSessionTurn({ runner: sessionRunner, ...turnOptions })
+      : runStreamTurn({ engine, ...turnOptions });
   };
 
   let lastResult = null;
@@ -820,6 +856,7 @@ async function runStreamJson(config, args) {
     }
   } finally {
     input?.close();
+    await sessionRunner?.close();
     await loaded.shutdown();
     console.log = originalConsole.log;
     console.info = originalConsole.info;
@@ -836,18 +873,42 @@ async function runOnce(config, args) {
     return;
   }
 
-  // Use loadSession() to wire all subsystems
+  const workDir = resolve(args.workDir || process.cwd());
+  const persisted = args.sessionId ? loadSessionConfig(config.dir, args.sessionId) : {};
+  const effectiveConfig = resolveSessionConfig(config, persisted);
   const session = await loadSession({
-    model: args.model || config.model,
-    language: args.language || config.language,
-    debug: args.debug || config.debug,
+    dir: config.dir,
+    workDir,
+    model: args.model || effectiveConfig.model,
+    language: args.language || effectiveConfig.language,
+    debug: args.debug || effectiveConfig.debug,
     skipMCP: args.skipMCP,
     skipSkills: args.skipSkills,
+    configOverrides: effectiveConfig,
   });
 
   const { engine, conversationStore } = session;
+  const sessionRunner = args.sessionId
+    ? createCliSessionRunner({ loaded: session, sessionId: args.sessionId, workDir })
+    : null;
 
   try {
+    if (args.sessionId && !sessionRunner) {
+      throw new Error(`Session not found: ${args.sessionId}`);
+    }
+    if (sessionRunner) {
+      const outcome = await sessionRunner.run(args.prompt, {
+        modelEffort: args.modelEffort || session.config.modelEffort || null,
+        onEvent: ({ vpId, event }) => {
+          if (event.type === 'text_delta') process.stdout.write(`\n[${vpId}] ${event.text || ''}`);
+          else if (event.type === 'tool_start') process.stderr.write(`\n[${vpId}] ${event.name}...\n`);
+          else if (event.type === 'error') process.stderr.write(`\n[${vpId}] Error: ${event.error?.message || event.error}\n`);
+        },
+      });
+      console.log();
+      if (outcome.results.some(result => result.error)) process.exitCode = 1;
+      return;
+    }
     // Load recent conversation as context
     const priorMessages = conversationStore.loadRecent(20).map(m => ({
       role: m.role,
@@ -903,6 +964,7 @@ async function runOnce(config, args) {
     // Final newline after streaming text
     console.log();
   } finally {
+    await sessionRunner?.close();
     await session.shutdown();
   }
 }

package/yeaft/stdio-protocol.js

@@ -297,3 +297,167 @@ export async function runStreamTurn({
   write(result);
   return result;
 }
+
+/**
+ * Run one prompt through the multi-VP CLI Session runner. Engine events keep
+ * the stream-json shape used by runStreamTurn and add `vp_id`, allowing
+ * concurrent VP streams to be demultiplexed without imposing output order.
+ */
+export async function runStreamSessionTurn({
+  runner,
+  prompt,
+  sessionId,
+  workDir = process.cwd(),
+  model = null,
+  modelEffort = null,
+  input = null,
+  write,
+}) {
+  const clientTurnId = randomUUID();
+  const states = new Map();
+  let failed = null;
+
+  const stateFor = (vpId) => {
+    let state = states.get(vpId);
+    if (!state) {
+      state = {
+        turnId: clientTurnId,
+        resultText: '',
+        stopReason: 'end_turn',
+        usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cacheInputDeltaTokens: 0 },
+      };
+      states.set(vpId, state);
+    }
+    return state;
+  };
+
+  const askUser = async ({ question, options }, vpId = null, turnId = clientTurnId) => {
+    const requestId = randomUUID();
+    write({
+      type: 'ask_user', subtype: 'request', request_id: requestId,
+      session_id: sessionId, turn_id: turnId, vp_id: vpId,
+      question, options: Array.isArray(options) ? options : [],
+    });
+    if (!input) throw new Error('AskUser requires --input-format stream-json');
+    const answers = await input.waitForAnswer(requestId);
+    write({
+      type: 'ask_user', subtype: 'response', request_id: requestId,
+      session_id: sessionId, turn_id: turnId, vp_id: vpId, answers,
+    });
+    return answers;
+  };
+
+  const onEvent = async ({ vpId, event, turnId: fallbackTurnId }) => {
+    const state = stateFor(vpId);
+    if (event.type === 'turn_open' && event.turnId) state.turnId = event.turnId;
+    const turnId = state.turnId || fallbackTurnId || clientTurnId;
+    const base = { session_id: sessionId, turn_id: turnId, vp_id: vpId };
+    switch (event.type) {
+      case 'turn_open':
+        write({ ...event, type: 'turn', subtype: 'start', ...base, model, model_effort: modelEffort, cwd: workDir });
+        break;
+      case 'text_delta':
+        state.resultText += event.text || '';
+        write({ type: 'assistant', subtype: 'text_delta', ...base, delta: { type: 'text_delta', text: event.text || '' } });
+        break;
+      case 'thinking_delta':
+        write({ type: 'assistant', subtype: 'thinking_delta', ...base, delta: { type: 'thinking_delta', thinking: event.text || '' } });
+        break;
+      case 'skill_loaded':
+        write({ type: 'skill', subtype: 'loaded', ...base, skill: event.skill });
+        break;
+      case 'skill_error':
+        write({ type: 'skill', subtype: 'error', ...base, skill_name: event.skillName, error: event.message });
+        break;
+      case 'tool_call':
+        write({ type: 'assistant', subtype: 'tool_use', ...base, content: [{ type: 'tool_use', id: event.id, name: event.name, input: event.input }] });
+        if (event.name === 'TodoWrite') {
+          write({ type: 'todo', subtype: 'update', ...base, tool_use_id: event.id, todos: event.input?.todos || [] });
+        }
+        break;
+      case 'tool_start':
+        write({ type: 'tool', subtype: 'start', ...base, tool_use_id: event.id, name: event.name, input: event.input });
+        break;
+      case 'tool_end':
+        write({ type: 'tool', subtype: 'result', ...base, tool_use_id: event.id, name: event.name, content: event.output, is_error: !!event.isError });
+        break;
+      case 'usage': {
+        const cacheDelta = event.cacheTokensAreIncludedInInput ? 0 : (event.cacheReadTokens || 0) + (event.cacheWriteTokens || 0);
+        state.usage.inputTokens += event.inputTokens || 0;
+        state.usage.outputTokens += event.outputTokens || 0;
+        state.usage.cacheReadTokens += event.cacheReadTokens || 0;
+        state.usage.cacheWriteTokens += event.cacheWriteTokens || 0;
+        state.usage.cacheInputDeltaTokens += cacheDelta;
+        write({ type: 'usage', ...base, usage: snakeUsage(event) });
+        break;
+      }
+      case 'stop':
+      case 'turn_end':
+        if (event.stopReason && TERMINAL_STOP_REASONS.has(event.stopReason)) state.stopReason = event.stopReason;
+        break;
+      case 'turn_close':
+        write({ type: 'turn', subtype: 'stop', ...base, duration_ms: event.totalMs, loop_count: event.loopCount, total_tokens: event.totalTokens });
+        break;
+      case 'error':
+        failed ||= event.error instanceof Error ? event.error : new Error(event.error?.message || String(event.error || 'Unknown error'));
+        write({ type: 'error', ...base, error: { name: failed.name, message: failed.message }, retryable: !!event.retryable });
+        break;
+      case 'fallback':
+      case 'llm_retry':
+      case 'memory_used':
+      case 'recall':
+      case 'consolidate':
+      case 'reflection':
+        write({ ...event, ...base });
+        break;
+    }
+  };
+
+  let outcome;
+  try {
+    outcome = await runner.run(prompt, {
+      modelEffort,
+      onEvent,
+      askUser,
+    });
+  } catch (error) {
+    failed = error;
+    write({ type: 'error', session_id: sessionId, turn_id: clientTurnId, error: { name: error.name || 'Error', message: error.message || String(error) } });
+    outcome = { report: { dispatched: [] }, results: [] };
+  }
+
+  const perVp = Array.from(states, ([vpId, state]) => ({
+    vp_id: vpId,
+    turn_id: state.turnId,
+    stop_reason: state.stopReason,
+    result: state.resultText,
+    usage: {
+      input_tokens: state.usage.inputTokens,
+      output_tokens: state.usage.outputTokens,
+      cache_read_input_tokens: state.usage.cacheReadTokens,
+      cache_creation_input_tokens: state.usage.cacheWriteTokens,
+      total_input_tokens: state.usage.inputTokens + state.usage.cacheInputDeltaTokens,
+      total_tokens: state.usage.inputTokens + state.usage.cacheInputDeltaTokens + state.usage.outputTokens,
+    },
+  }));
+  const stopReasons = perVp.map(item => item.stop_reason);
+  const aggregateStopReason = failed || stopReasons.includes('error')
+    ? 'error'
+    : stopReasons.length > 0 && stopReasons.every(reason => reason === 'aborted')
+      ? 'aborted'
+      : 'end_turn';
+  const isError = !!failed || aggregateStopReason === 'error';
+  const result = {
+    type: 'result', subtype: isError ? 'error' : 'success',
+    session_id: sessionId, turn_id: clientTurnId,
+    model, model_effort: modelEffort,
+    stop_reason: aggregateStopReason,
+    is_error: isError,
+    result: perVp.map(item => item.result).filter(Boolean).join('\n'),
+    dispatched_vp_ids: outcome?.report?.dispatched || [],
+    vp_results: perVp,
+    ...(failed ? { error: failed.message || String(failed) } : {}),
+  };
+  write(result);
+  return result;
+}