@livx.cc/agentx 0.99.100 → 0.99.101

package/dist/cli.d.ts

@@ -3,6 +3,9 @@ import { m as RouterState, H as Hooks, n as RunResult, R as ReasoningEffort, A a
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, o as MessageContent } from './tools-lC3jn60o.js';
 
+/** How talkative the second channel is (`--channel-mode`). */
+type ChannelMode = 'turn' | 'normal' | 'chatty';
+
 /**
  * On-disk session store for the CLI: each conversation is one JSON file at
  * `<cwd>/.agent/sessions/<id>.json`. Writes are atomic (temp + rename) so a crash
@@ -142,6 +145,7 @@ interface Args {
     duplex: boolean;
     duplexV2?: boolean;
     channelOnly?: boolean;
+    channelMode?: ChannelMode;
     voiceModel?: string;
     thinkModel?: string | false;
     voice: boolean;

package/dist/cli.js

@@ -14071,7 +14071,34 @@ Reply JSON only: {"turn":"...","density":"...","cues":[{"when":["phrase",...],"l
 
 // src/voice/secondChannel.ts
 var log31 = forComponent("SecondChannel");
+var CHANNEL_MODES = {
+  turn: { kinds: ["bridge"], bridgeDelayMs: 1500 },
+  normal: {},
+  chatty: {
+    anticipate: true,
+    cueOnly: false,
+    generateFor: ["backchannel", "bridge"],
+    reactionGapMs: 6e3,
+    generateBudgetMs: 400,
+    backchannelMinWords: 5,
+    backchannelGapMs: 1200,
+    minGapMs: 1200,
+    backchannelPauseMs: 250
+  }
+};
+var CHANNEL_MODE_NAMES = Object.keys(CHANNEL_MODES);
+function parseChannelMode(v) {
+  if (!v) return "normal";
+  if (!(v in CHANNEL_MODES)) throw new Error(`unknown channel mode "${v}" (${CHANNEL_MODE_NAMES.join("|")})`);
+  return v;
+}
 var SecondChannelOptions = class {
+  /** Preset (CHANNEL_MODES) under the explicit options. */
+  mode = "normal";
+  /** Line kinds this channel may speak. */
+  kinds = ["backchannel", "filler", "bridge"];
+  /** A generated (content) backchannel needs this long since the last one; in between, canned light cues. 0 = always. */
+  reactionGapMs = 0;
   /** Refiner (Jev/fast LLM): the choice over CHANNEL_ACTIONS, or null on failure. Absent → the rule alone decides.
    *  `state.rule` is the kind the rule proposed (fastChannelDecider answers yes/no on it). `signal` aborts a late call. */
   decide;
@@ -14166,7 +14193,10 @@ function withBudget(p, ms, what, ac) {
 var SecondChannel = class {
   constructor(options) {
     this.options = options;
-    this.options = { ...new SecondChannelOptions(), ...options };
+    const preset = CHANNEL_MODES[options?.mode ?? "normal"] ?? {};
+    const base = new SecondChannelOptions();
+    this.options = { ...base, ...preset, ...options };
+    for (const k of Object.keys(preset)) if (!options || !(k in options)) this.normalTiming[k] = base[k];
     this.startedAt = this.o.now();
     if (this.o.lang) this.setLanguage(this.o.lang, true);
   }
@@ -14213,6 +14243,10 @@ var SecondChannel = class {
   reply = "";
   // channel-1's text this turn (the plan's context)
   lastUser = "";
+  lastReactAt = -Infinity;
+  normalTiming = {};
+  // chatty without aec: the preset's keys back at their defaults
+  degradedLogged = false;
   /** The language lines are spoken in (detected from the user's words, or set by the host). */
   get language() {
     return this.lang;
@@ -14241,7 +14275,13 @@ var SecondChannel = class {
     return this.lang ? this.o.banks ? this.o.banks.get(this.lang) : this.lang === "en" ? EN_BANK : null : null;
   }
   get o() {
-    return this.options;
+    const o = this.options;
+    if (o.mode !== "chatty" || o.aec) return o;
+    if (!this.degradedLogged) {
+      this.degradedLogged = true;
+      log31.info("chatty mode without echo cancellation \u2014 normal timing (our lines would re-trigger the mic)");
+    }
+    return { ...o, ...this.normalTiming };
   }
   /** The user's live partial for the current turn (the whole partial, not a delta). */
   onInterim(text) {
@@ -14377,6 +14417,7 @@ var SecondChannel = class {
   }
   /** Hard gates every line passes, whoever proposed it. */
   allowed(k) {
+    if (!this.o.kinds.includes(k)) return false;
     if (this.audioLocked || this.inflight || this.o.now() - this.lastAt < this.o.minGapMs || k === this.lastKind && (k !== "backchannel" || this.o.now() - this.lastAt < this.o.backchannelGapMs)) return false;
     if (k === "backchannel") return this.o.aec && this.userSpeaking && this.main === "idle";
     if (k === "filler") return !this.userSpeaking && this.main === "idle";
@@ -14443,12 +14484,14 @@ var SecondChannel = class {
       if (kind === "silence") return ev({ choice, acted: "silence" });
       if (stale()) return ev({ choice, kind, acted: "stale" });
       if (!this.allowed(kind)) return ev({ choice, kind, acted: "gated" });
-      const text = cue && !this.recent.some((r) => norm2(r) === norm2(cue.line)) ? cue.line : await this.line(kind);
+      const react = kind === "backchannel" && this.o.now() - this.lastReactAt >= this.o.reactionGapMs;
+      const text = cue && react && !this.recent.some((r) => norm2(r) === norm2(cue.line)) ? cue.line : await this.line(kind, react);
       if (!text) return ev({ choice, kind, acted: "no_bank" });
       if (stale()) return ev({ choice, kind, text, acted: "stale" });
       if (!this.allowed(kind)) return ev({ choice, kind, text, acted: "gated" });
       const said = this.say(kind, text);
       if (said && cue) this.cueFrom = words2(this.heard).length;
+      if (said && kind === "backchannel" && this.o.reactionGapMs && !this.bank?.backchannel.some((b) => norm2(b) === norm2(text))) this.lastReactAt = this.o.now();
       ev({ choice, kind, text, acted: said ? "spoken" : "skipped" });
     } finally {
       this.busy = false;
@@ -14465,10 +14508,10 @@ var SecondChannel = class {
       call_ms: Math.round(now4 - this.startedAt)
     };
   }
-  async line(kind) {
-    if (this.o.generate && this.o.generateFor.includes(kind)) {
+  async line(kind, react = true) {
+    if (this.o.generate && this.o.generateFor.includes(kind) && (kind !== "backchannel" || react)) {
       const ac = new AbortController();
-      const ctx = { kind, heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang };
+      const ctx = { kind, heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang, ...kind === "backchannel" && this.o.reactionGapMs ? { react: true } : {} };
       const raw = await withBudget(this.o.generate(ctx, ac.signal), this.o.generateBudgetMs, `${kind} generate`);
       if (raw === null) ac.abort();
       const text = cleanLine(raw ?? "", this.lang);
@@ -14543,10 +14586,12 @@ var KIND_HINT2 = {
   filler: 'a soft listener sound while THEY search for words ("mm\u2026", "mhm", "yeah\u2026") \u2014 never a word that continues their sentence or starts yours',
   bridge: 'a neutral one-moment cue while the answer is prepared ("let me see\u2026", "one sec\u2026") \u2014 never the start of a statement or opinion ("the thing is", "well actually")'
 };
+var REACT_HINT = 'a short reaction to their LAST words instead: feeling ("oh no", "ha, nice", "ugh"), surprise ("wait, really?", "huh"), a light laugh if they joke or laugh ("ha!"), or an echo of their key word ("the deploy?") \u2014 still never asks for an answer or takes the turn; if nothing there deserves a reaction, a plain "mm-hm"';
 function fastLineGenerator(ai, model) {
   return async (c, signal) => {
     const prompt = `You voice the tiny side-sounds of a live spoken conversation. Write ONE line of 1-5 words: ${KIND_HINT2[c.kind]}.
-The user just said: "${c.heard}"
+` + (c.react ? `Here the line may be ${REACT_HINT}.
+` : "") + `The user just said: "${c.heard}"
 The assistant is: ${c.state}.
 ` + (c.avoid.length ? `Do not reuse any of: ${c.avoid.map((a) => `"${a}"`).join(", ")}.
 ` : "") + `React to their actual words, casually, in ${languageName(c.lang)}. Output only the line.`;
@@ -17687,6 +17732,7 @@ function parseArgs(argv) {
       a.duplex = true;
       a.duplexV2 = true;
     } else if (x === "--channel-only") a.channelOnly = true;
+    else if (x === "--channel-mode") a.channelMode = parseChannelMode(val(++i, x));
     else if (x === "--conversational" || x === "--convo" || x === "--voice") {
       a.voice = true;
       a.duplex = true;
@@ -17730,6 +17776,8 @@ function parseArgs(argv) {
   if (a.channelOnly && !a.inputFormat) throw new Error("--channel-only needs --input-format stream-json --output-format stream-json");
   if (a.duplex && a.plan) throw new Error("--plan is not supported in --duplex (workers are non-interactive; a plan could never be approved)");
   if (a.voiceSystemPrompt && !a.duplex) throw new Error("--voice-system-prompt only applies with --duplex");
+  if (a.channelMode && !a.duplexV2 && !a.channelOnly) throw new Error("--channel-mode only applies with --duplex-v2 or --channel-only");
+  a.channelMode ??= parseChannelMode(process.env.AGENTX_CHANNEL_MODE);
   if (a.voiceModel && !a.duplex && !a.channelOnly) throw new Error("--voice-model only applies with --duplex or --channel-only");
   if (a.thinkModel !== void 0 && !a.duplex) throw new Error("--think-model/--no-think only apply with --duplex");
   if (!canPrompt && (a.ask || a.plan))
@@ -17776,6 +17824,9 @@ Flags:
                        enter the agent's history (headless: stdin interim/pause/agent_state, stdout channel)
   --channel-only       headless (--input-format stream-json): ONLY the second channel, for a host whose main
                        answer comes from elsewhere (stdin user/text/barge/interim/pause/agent_state, stdout channel)
+  --channel-mode <m>   second-channel talkativeness: turn (only a bridge when the answer is slow) | normal
+                       (default) | chatty (frequent cues + content reactions; needs echo cancellation)
+                       env fallback: AGENTX_CHANNEL_MODE
   --conversational     duplex with a conversation-native register \u2014 short fast turns, fillers,
                        impulsive reactions, human pacing (implies --duplex; aliases: --convo, --voice)
                        with SONIOX_API_KEY + CARTESIA_API_KEY(+VOICE_ID) set: real voice I/O \u2014 mic in,
@@ -21040,7 +21091,7 @@ ${out}
       if (dx) dx.options.holdResumeMs = HOLD_RESUME_MS;
       if (args.duplexV2 && dx) {
         const v = voiceIO;
-        bindSecondChannel(v, makeSecondChannel(ai, dx.options.reflexModel, { show: (t) => {
+        bindSecondChannel(v, makeSecondChannel(ai, dx.options.reflexModel, args.channelMode, { show: (t) => {
           err("\r\x1B[0J" + dim(`  \u21B3 ${t}
 `));
           editorRef?.redrawNow();
@@ -21297,7 +21348,7 @@ function duplexError(e, reflexModel) {
 }
 var HOLD_RESUME_MS = 4e3;
 var leakDecider = () => voiceDecider();
-function makeSecondChannel(ai, reflexModel, opts) {
+function makeSecondChannel(ai, reflexModel, mode = "normal", opts) {
   const decider = leakDecider();
   const instinct = decider ? new Instinct({ decider }) : void 0;
   const model = process.env.AGENTX_CHANNEL_MODEL || reflexModel;
@@ -21307,8 +21358,10 @@ function makeSecondChannel(ai, reflexModel, opts) {
     banks: new ChannelBanks({ generate: fastBankGenerator(ai, model), cacheDir: join16(homedir10(), ".agent", "cache", "channel-banks") }),
     decide: channelDecide(ai, instinct),
     generate: fastLineGenerator(ai, model),
-    // Anticipated backchannels (off until the offline replay proves them — tests/voice-bc-anticipate-eval.ts)
-    ...process.env.AGENTX_CHANNEL_ANTICIPATE === "1" ? { anticipate: true, plan: (c, s) => planner.plan(c, s) } : {},
+    mode,
+    // Anticipated backchannels: on in chatty mode (its preset), else off until the offline replay proves them (tests/voice-bc-anticipate-eval.ts)
+    plan: (c, s) => planner.plan(c, s),
+    ...process.env.AGENTX_CHANNEL_ANTICIPATE === "1" ? { anticipate: true } : {},
     onEvent: (e) => log37.debug(`channel ${e.trigger}: rule=${e.rule} choice=${e.choice ?? "-"} \u2192 ${e.acted}${e.text ? ` "${e.text}"` : ""}${e.cue ? " (planned cue)" : ""} ${e.ms}ms`),
     ...opts
   });
@@ -21362,7 +21415,7 @@ async function duplexServe(args, ai, cfg, cwd) {
   });
   if (args.voiceSystemPrompt) dx.voice.options.systemPrompt += "\n\n" + args.voiceSystemPrompt;
   let scTurn = 0;
-  const sc = args.duplexV2 ? makeSecondChannel(ai, dx.options.reflexModel, { show: (text, kind) => out({ type: "channel", kind, text }) }) : void 0;
+  const sc = args.duplexV2 ? makeSecondChannel(ai, dx.options.reflexModel, args.channelMode, { show: (text, kind) => out({ type: "channel", kind, text }) }) : void 0;
   const store = new SessionStore(cwd);
   const session = startSession(args, store, dx.voice, cwd);
   persist = () => {
@@ -21427,8 +21480,8 @@ async function channelServe(args, ai, cfg) {
   const out = (o) => process.stdout.write(JSON.stringify(o) + "\n");
   const { reflexModel, notes } = duplexModels({ voiceModel: args.voiceModel, reflexModel: cfg.reflexModel, thinkModel: false, actModel: String(args.model ?? cfg.model ?? ""), apiKeys: { ...cfg.apiKeys, ...apiKeysFromEnv() } });
   const model = reflexModel ?? new DuplexAgentOptions().reflexModel;
-  const sc = makeSecondChannel(ai, model, { show: (text, kind) => out({ type: "channel", kind, text }) });
-  out({ type: "ready", model, ...notes.length ? { notes } : {} });
+  const sc = makeSecondChannel(ai, model, args.channelMode, { show: (text, kind) => out({ type: "channel", kind, text }) });
+  out({ type: "ready", model, channelMode: args.channelMode, ...notes.length ? { notes } : {} });
   const rl = createInterface({ input: process.stdin });
   rl.on("line", (line) => {
     let m;