@yeaft/webchat-agent 1.0.289 → 1.0.292

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;
+}

package/yeaft/web-bridge.js

@@ -3978,6 +3978,7 @@ function handleEngineEvent(event, hctx) {
         type: 'memory_used',
         turnId: event.turnId,
         loaded: event.loaded || [],
+        meta: event.meta || null,
       }, envelope);
       break;