@livx.cc/agentx 0.99.99 → 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

@@ -3432,7 +3432,7 @@ function copyTextToClipboard(text, platform2 = process.platform) {
 
 // cli/cli.ts
 import { join as join16, resolve as resolve5, basename as basename4, extname, dirname as dirname6 } from "path";
-import { AIClient, DecideClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions, disposeClaudeCodeSessions } from "ai.libx.js";
+import { AIClient as AIClient2, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions, disposeClaudeCodeSessions } from "ai.libx.js";
 
 // src/ccBridge.ts
 var CC_BRIDGED = /* @__PURE__ */ new Set(["Recall", "Remember", "MemorySearch"]);
@@ -9251,12 +9251,20 @@ configureLogging((name) => {
 
 // src/voice/instinct.ts
 init_logging();
+import { AIClient, DecideClient, JevAdapter, LlmDecideAdapter } from "ai.libx.js";
 var log19 = forComponent("Instinct");
 function voiceDeciderOptions(env = process.env) {
   if (env.TYPESAFE_AI_KEY) return { apiKey: env.TYPESAFE_AI_KEY };
   if (env.GROQ_API_KEY) return { provider: "llm", model: "groq/openai/gpt-oss-120b", apiKey: env.GROQ_API_KEY };
   return void 0;
 }
+function voiceDecider(env = process.env, timeoutMs = 1500) {
+  const o = voiceDeciderOptions(env);
+  if (!o) return void 0;
+  const ai = new AIClient();
+  const llm = new LlmDecideAdapter({ client: { chat: (c) => ai.chat({ reasoningEffort: "low", ...c }) } });
+  return new DecideClient({ ...o, timeoutMs, adapters: { typesafe: new JevAdapter(), llm } });
+}
 var InstinctOptions = class {
   decider;
   /** Partial unchanged this long (a micro-pause) → consult. */
@@ -14063,9 +14071,36 @@ 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 (fastBackchannelDecider answers only 'backchannel' moments). */
+   *  `state.rule` is the kind the rule proposed (fastChannelDecider answers yes/no on it). `signal` aborts a late call. */
   decide;
   /** Fast-model line writer (see fastLineGenerator). Absent or late → the canned bank. */
   generate;
@@ -14141,11 +14176,12 @@ var SecondChannelOptions = class {
   random = Math.random;
 };
 var words2 = (s) => s.trim() ? s.trim().split(/\s+/) : [];
-function withBudget(p, ms, what) {
+function withBudget(p, ms, what, ac) {
   let t;
   const late = new Promise((r) => {
     t = setTimeout(() => {
       log31.debug(`${what}: over the ${ms}ms budget \u2014 dropped`);
+      ac?.abort();
       r(null);
     }, ms);
   });
@@ -14157,7 +14193,10 @@ function withBudget(p, ms, what) {
 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);
   }
@@ -14204,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;
@@ -14232,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) {
@@ -14368,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";
@@ -14425,7 +14475,8 @@ var SecondChannel = class {
       let kind = rule;
       let choice;
       if (this.o.decide && !cue) {
-        const d = await withBudget(this.o.decide(this.tail(), { ...this.state(pauseMs), rule }), this.o.decisionBudgetMs, "channel decision");
+        const ac = new AbortController();
+        const d = await withBudget(this.o.decide(this.tail(), { ...this.state(pauseMs), rule }, ac.signal), this.o.decisionBudgetMs, "channel decision", ac);
         choice = d?.choice;
         if (choice && choice in CHANNEL_ACTIONS && (choice === "silence" || this.allowed(choice))) kind = choice;
         else if (choice && choice in CHANNEL_ACTIONS) log31.debug(`decider chose ${choice} for a ${rule} moment \u2014 the rule stands`);
@@ -14433,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;
@@ -14455,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);
@@ -14505,32 +14558,40 @@ var SecondChannel = class {
     return true;
   }
 };
-function fastBackchannelDecider(ai, model = "groq/qwen/qwen3.8-27b") {
-  return async (heard, state) => {
-    if (state.rule !== "backchannel") return null;
-    const prompt = `Live voice call. The user is still talking and just took a breath. So far: "${heard}"
-Would an attentive human listener say a tiny "mm-hm" now? Yes ONLY if they are telling a story/explaining across several clauses. No if it is a request, command, question, or they are mid-request. Answer yes or no.`;
+var FAST_ASK = {
+  backchannel: 'The user is still talking and just took a breath. Would an attentive human listener say a tiny "mm-hm" now? Yes ONLY if they are telling a story/explaining across several clauses. No if it is a request, command, question, or they are mid-request.',
+  filler: 'The user went quiet mid-turn. Would a human listener make a soft "hmm\u2026" now? Yes ONLY if their sentence is unfinished and they are searching for words. No if they said a complete request, question, answer, thanks or remark (the reply comes next).',
+  bridge: `The user finished and the assistant's answer is taking a moment. Would a human say a short "let me check\u2014" now? Yes if they asked for real work or a substantial/hard question. No for small talk, a greeting, thanks, an ok/yes/agreement.`
+};
+function fastChannelDecider(ai, model = "groq/qwen/qwen3.8-27b") {
+  return async (heard, state, signal) => {
+    const kind = state.rule;
+    if (!(kind in FAST_ASK)) return null;
+    const prompt = `Live voice call. ${FAST_ASK[kind]}
+So far the user said: "${heard}"
+Answer yes or no.`;
     const reasoning = /qwen/.test(model) ? { providerOptions: { reasoning_effort: "none" } } : /gpt-oss/.test(model) ? { providerOptions: { reasoning_effort: "low" } } : {};
-    const r = await ai.chat({ model, messages: [{ role: "user", content: prompt }], stream: false, maxTokens: /gpt-oss/.test(model) ? 200 : 3, ...reasoning });
+    const r = await ai.chat({ model, messages: [{ role: "user", content: prompt }], stream: false, signal, temperature: 0, maxTokens: /gpt-oss/.test(model) ? 200 : 3, ...reasoning });
     const a = (r.content ?? "").trim().toLowerCase();
-    return /^yes/.test(a) ? { choice: "backchannel" } : /^no/.test(a) ? { choice: "silence" } : null;
+    return /^yes/.test(a) ? { choice: kind } : /^no/.test(a) ? { choice: "silence" } : null;
   };
 }
 function channelDecide(ai, instinct, env = process.env) {
   const model = env.AGENTX_CHANNEL_DECIDER_MODEL || void 0;
-  const bc = model || env.GROQ_API_KEY ? fastBackchannelDecider(ai, model) : void 0;
-  if (!bc && !instinct) return void 0;
-  return async (heard, state) => bc && state.rule === "backchannel" ? bc(heard, state) : instinct ? instinct.channel(heard, state) : null;
+  if (model || env.GROQ_API_KEY) return fastChannelDecider(ai, model);
+  return instinct ? (heard, state) => instinct.channel(heard, state) : void 0;
 }
 var KIND_HINT2 = {
   backchannel: 'a tiny listener cue while they keep talking ("mm-hm", "right", "yeah") \u2014 shows you follow, never takes the turn',
   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.`;
@@ -17671,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;
@@ -17714,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))
@@ -17760,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,
@@ -21024,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();
@@ -21280,11 +21347,8 @@ function duplexError(e, reflexModel) {
   return code && !msg.includes(String(code)) ? `${msg} (${code})` : msg;
 }
 var HOLD_RESUME_MS = 4e3;
-var leakDecider = () => {
-  const o = voiceDeciderOptions();
-  return o ? new DecideClient(o) : void 0;
-};
-function makeSecondChannel(ai, reflexModel, opts) {
+var leakDecider = () => voiceDecider();
+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;
@@ -21294,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
   });
@@ -21349,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 = () => {
@@ -21414,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;
@@ -21550,7 +21616,7 @@ async function main() {
     console.error(red("No provider key found. Set ANTHROPIC_API_KEY (or OPENAI_API_KEY / GOOGLE_API_KEY / GROQ_API_KEY) in ~/.agent/.env, or set BODIFY_API_KEY + BODIFY_APP_ID to pull from Bodify."));
     process.exit(1);
   }
-  const ai = new AIClient({
+  const ai = new AIClient2({
     apiKeys,
     ...cfg.baseUrls ? { baseUrls: cfg.baseUrls } : {},
     retry: {