@livx.cc/agentx 0.99.61 → 0.99.62

package/README.md

@@ -119,6 +119,7 @@ agentx --resume <id> "…"    # resume a specific session
 - **Raise, don't guess** (`AskUserQuestion` + `finishReason: 'needs_input'`) — when a decision is genuinely the user's, the agent asks. Interactively that's an arrow-select prompt. **Headless** (`-p`, piped, no TTY) there's nobody to prompt, so instead of blocking on a prompt no one can see — or, worse, "proceeding with best judgment" — the run **stops and hands the question to its caller**: exit code `2`, a yellow `? needs input` footer, and `{finishReason:'needs_input', question:{…}, sessionId}` in `--output-format json`. The transcript is preserved, so the caller answers and continues (`--resume <id> -p "<answer>"`) instead of re-running. A delegated agent silently deciding something that was never its to decide is the failure this closes.
 - **Tab-completion** — `Tab` completes `/<command>` names and `@<path>` file/dir references (descends subdirs, dotfiles hidden unless typed) straight from the working tree.
 - **Duplex mode** — `agentx --duplex` runs the full standard REPL (slash commands, sessions, postures, rewind, MCP) with the three-tier engine driving turns: a fast voice model (`--voice-model`, default `groq/openai/gpt-oss-120b`) answers every line instantly and delegates real work to background workers built with the same wiring as a normal run (fs mode, permissions, MCP); worker activity shows as dim chrome and results are re-voiced when ready. Switch any tier live with `/model` (opens a reflex/act/think picker), or the `/voice-model` · `/think-model` shortcuts. `/tasks` lists background tasks, inspects a task's live output tail, and cancels a running one from a picker (Esc mid-turn cancels the foreground turn; Esc again at the idle prompt cancels running workers).
+- **Headless duplex for host apps** — `agentx --voice --input-format stream-json --output-format stream-json` runs the same duplex engine behind an NDJSON pipe, for an app that owns its own mic/TTS (the Bare browser uses it). stdin: `{type:'user', text, id?, replaces?, cut?}` (`cut` = the host voice engine's `takeInterruptedReply()`, so "heard up to" / parked deliveries work exactly as in the CLI), `{type:'barge'}`, `{type:'cancel', task}`, `{type:'exit'}`. stdout: reflex `text`/`thinking` deltas, worker `speak` utterances, `filler`, `task` lifecycle events, `turn_done`, `revoice_done`, `exit`. `--append-system-prompt` goes to the workers, `--voice-system-prompt` to the voice model.
 - **MCP servers** — declare `mcpServers: { name: { command, args } | { url } }` in config and they're auto-mounted at startup (in parallel, with an optional `mountTimeoutMs` deadline so one slow/dead server never blocks the rest): the client does the JSON-RPC handshake (stdio or HTTP) + `tools/list`, and the discovered tools appear as `mcp__<name>__<tool>` in `/tools` (inspect with `/mcp`). A bad server is logged and skipped, never blocking the agent. For large tool sets, **deferred mode** (`makeMcpToolSearch` / `mountMcpDeferred`) exposes just two bounded tools (`ToolSearch` + `McpCall`) instead of N defs — dodging the provider tool-cap and improving selection accuracy; the CLI applies this automatically past 12 mounted tools (a 42-tool server was costing ~80k tok/turn in schema alone), and permission rules written against the real `mcp__<name>__<tool>` names still match through `McpCall`. **`mountMcpCatalog`** goes further: a cached, hash-keyed catalog + lazy connect means a turn that uses no MCP tool opens **zero** connections, and one that uses a tool connects exactly that server — latency scales with tools-used, not servers-configured. A down server is **negative-cached** (`failureCooldownMs`) so it never re-floors a later turn at the deadline. For zero turn-path latency even on a cold process, call **`warmMcpCatalog`** at boot + on a timer (off-turn discovery) and mount with **`{ discover: 'cache-only' }`** — the turn then never synchronously connects: it serves the warmed catalog and discovers any miss in the background. **Slow tools are jobs, not timeouts**: `timeoutMs` (default 30s) bounds protocol requests (`initialize`, `tools/list`) only; a `tools/call` still running after the soft foreground timeout (`foregroundMs.mcp`, 30s) returns `[still running] … background job job-N` while the request keeps going, and its result is delivered when it lands. The client sends a `progressToken` and reads progress over stdio and incrementally over HTTP/SSE; a call is cancelled (`notifications/cancelled`) only by `JobKill`, the stuck-job reaper, or its hard cap `callTimeoutMs` (per server, default 30 min).
 
 ## 🧬 It improves itself

package/dist/cli.d.ts

@@ -141,9 +141,11 @@ interface Args {
     sessionId?: string;
     fork?: boolean;
     outputFormat: 'text' | 'json' | 'stream-json';
+    inputFormat?: 'stream-json';
     allowedTools?: string[];
     disallowedTools?: string[];
     appendSystemPrompt?: string;
+    voiceSystemPrompt?: string;
     addDirs?: string[];
     print?: boolean;
     debug?: boolean;

package/dist/cli.js

@@ -10381,7 +10381,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     const rec = this.tasks.get(id);
     if (res.finishReason === "aborted" || rec.status === "cancelled") {
       rec.status = "cancelled";
-      this.notify("task_cancelled", `task ${id} (${rec.label}) cancelled`);
+      this.notify("task_cancelled", `task ${id} (${rec.label}) cancelled`, { id });
       return;
     }
     if (res.finishReason === "error") {
@@ -10433,7 +10433,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     rec.status = "error";
     rec.result = msg;
     log20.warn(`task ${rec.id} failed: ${msg}`);
-    this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
+    this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`, { id: rec.id });
     if (this.foldIfSuperseded(rec, `The "${rec.label}" task failed: ${msg}`)) return;
     this.dropParked(rec);
     this.queueRevoice(this.integrationPrompt(rec, "error", msg, "error"), true);
@@ -15733,6 +15733,7 @@ function parseArgs(argv) {
     else if (x === "--allowedTools" || x === "--allowed-tools") a.allowedTools = val(++i, x).split(",").map((s) => s.trim()).filter(Boolean);
     else if (x === "--disallowedTools" || x === "--disallowed-tools") a.disallowedTools = val(++i, x).split(",").map((s) => s.trim()).filter(Boolean);
     else if (x === "--append-system-prompt") a.appendSystemPrompt = val(++i, x);
+    else if (x === "--voice-system-prompt") a.voiceSystemPrompt = val(++i, x);
     else if (x === "--add-dir") (a.addDirs ??= []).push(val(++i, x));
     else if (x === "--reasoning") a.reasoning = parseReasoning(val(++i, x));
     else if (x === "--session-id") a.sessionId = val(++i, x);
@@ -15745,6 +15746,10 @@ function parseArgs(argv) {
       const f = argv[++i];
       if (f !== "text" && f !== "json" && f !== "stream-json") throw new Error(`invalid --output-format: ${f ?? "(missing)"} (use text|json|stream-json)`);
       a.outputFormat = f;
+    } else if (x === "--input-format") {
+      const f = argv[++i];
+      if (f !== "stream-json") throw new Error(`invalid --input-format: ${f ?? "(missing)"} (use stream-json)`);
+      a.inputFormat = f;
     } else if (x === "--") {
       rest.push(...argv.slice(i + 1));
       break;
@@ -15757,7 +15762,9 @@ function parseArgs(argv) {
   if (a.seed && !a.boddb) throw new Error("--seed only applies with --boddb (it seeds the database from cwd on first run)");
   if (a.worktree && (a.vfs || a.boddb)) throw new Error("--worktree is a real-disk concept \u2014 incompatible with --vfs/--boddb");
   if (a.duplex && (a.task || a.print)) throw new Error("--duplex is interactive-only (a conversational mode) \u2014 drop the task/-p");
+  if (a.inputFormat && (!a.duplex || a.outputFormat !== "stream-json")) throw new Error("--input-format stream-json is headless duplex \u2014 use it with --duplex (or --voice) and --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.voiceModel && !a.duplex) throw new Error("--voice-model only applies with --duplex");
   if (a.thinkModel !== void 0 && !a.duplex) throw new Error("--think-model/--no-think only apply with --duplex");
   if (!canPrompt && (a.ask || a.plan))
@@ -15807,6 +15814,7 @@ Flags:
   --voice-model <id>   with --duplex: the fast voice model (default groq/openai/gpt-oss-120b)
   --think-model <id>   with --duplex: the premium deep-reasoning model (default anthropic/claude-opus-4-6)
   --no-think           with --duplex: disable the Think tier (Act handles everything)
+  --voice-system-prompt <text>  with --duplex: appended to the voice (reflex) prompt only (--append-system-prompt \u2192 workers)
   --add-dir <path>     mount another directory into the workspace (repeatable; disk mode only)
   --subagents          allow the Task tool (spawn child agents)
   --reasoning <e>      extended thinking: off|low|medium|high or a token budget (anthropic/openai)
@@ -15816,6 +15824,8 @@ Flags:
   --max-steps <n>      step budget (default 30)
   --max-tokens <n>     token budget kill-switch (default 200000)
   --timeout <sec>      wall-clock kill-switch (default 120)
+  --input-format stream-json  with --duplex|--voice + --output-format stream-json: headless duplex for a host app
+                       (NDJSON turns/barge-ins on stdin, reflex text + worker speech + task events on stdout)
   --output-format <f>  headless output: text (default) | json (one result object) | stream-json (NDJSON events: {type:text|thinking}\u2026 then {type:result})
   -v, --version        print version and exit
   -h, --help
@@ -17210,6 +17220,7 @@ async function repl(args, ai, cfg, cwd) {
         exitRequested = true;
       })] }
     });
+    if (args.voiceSystemPrompt) dx.voice.options.systemPrompt += "\n\n" + args.voiceSystemPrompt;
   }
   const face = dx ? dx.voice : agent;
   const work = workerOptions ?? agent.options;
@@ -19208,6 +19219,88 @@ ${out}
   disposeClaudeCodeSessions();
   await closeMcp(mounted);
 }
+async function duplexServe(args, ai, cfg, cwd) {
+  const out = (o) => process.stdout.write(JSON.stringify(o) + "\n");
+  const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join14(cwd, ".agent", "mcp-auth.json") }));
+  installCancelGuards(mounted);
+  const agent = await makeAgent(args, ai, cfg, mcpAgentTools(mounted, { quiet: true }), mounted.map((m) => m.name));
+  const { host: _h, stream: _s, signal: _g, providerOptions: _po, ...wo } = agent.options;
+  const host = {
+    notify(e) {
+      const k = String(e.kind);
+      if (k === "text_delta") out({ type: "text", text: e.message });
+      else if (k === "thinking_delta") out({ type: "thinking", text: e.message });
+      else if (k === "speak_utterance") out({ type: "speak", text: e.message });
+      else if (k === "hold_filler") out({ type: "filler", text: e.message });
+      else if (k === "revoice_done") {
+        out({ type: "revoice_done" });
+        persist();
+      } else if (k.startsWith("task_")) out({ type: "task", kind: k.slice(5), id: e.data?.id, message: e.message, data: e.data });
+    }
+  };
+  let persist = () => {
+  };
+  const dx = new DuplexAgent({
+    ai,
+    fs: agent.options.fs,
+    memoryDir: agent.options.memoryDir,
+    memoryUserDir: agent.options.memoryUserDir,
+    ...args.voiceModel ?? cfg.reflexModel ? { reflexModel: resolveModelOrNewest(args.voiceModel ?? cfg.reflexModel) } : {},
+    actModel: agent.options.model,
+    actOptions: { ...wo, planMode: false },
+    providerOptionsFor: (m) => providerOptionsFor(m, cwd, cfg.mcpServers, mounted.map((x) => x.name)),
+    ...(args.thinkModel ?? cfg.thinkModel) !== void 0 ? { thinkModel: (args.thinkModel ?? cfg.thinkModel) === false ? false : resolveModelOrNewest(String(args.thinkModel ?? cfg.thinkModel)) } : {},
+    host,
+    // --voice: the CLI voice register (progress asides, spoken budget). No emotion tags: the host's TTS may not speak them.
+    ...args.voice ? { voiceStyle: "conversational", progressUpdates: true, spokenBudgetChars: 350 } : {},
+    reflexOptions: { fs: agent.options.fs, tools: [exitSessionTool(() => out({ type: "exit" }))] }
+  });
+  if (args.voiceSystemPrompt) dx.voice.options.systemPrompt += "\n\n" + args.voiceSystemPrompt;
+  const store = new SessionStore(cwd);
+  const session = startSession(args, store, dx.voice, cwd);
+  persist = () => {
+    session.messages = dx.voice.transcript;
+    session.meta.updated = Date.now();
+    try {
+      store.save(session);
+    } catch (e) {
+      log33.warn("duplex session save failed", e);
+    }
+  };
+  out({ type: "ready", sessionId: session.meta.id, reflexModel: dx.options.reflexModel, actModel: dx.options.actModel });
+  const done = new Promise((resolveDone) => {
+    const rl = createInterface({ input: process.stdin });
+    rl.on("line", (line) => {
+      let m;
+      try {
+        m = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (m.type === "barge") {
+        activeTurn?.abort();
+        dx.parkInFlightDeliveries();
+      } else if (m.type === "cancel") out({ type: "task", kind: "cancel_result", id: m.task, message: dx.cancelTask(String(m.task)) });
+      else if (m.type === "exit") rl.close();
+      else if (m.type === "user" && typeof m.text === "string" && m.text.trim()) {
+        const { reply, delivery, heard } = splitCut(m.cut ?? null);
+        if (delivery || reply) dx.parkCutDelivery(delivery, !!reply, heard);
+        const note = reply && reply.full.length - reply.heard.length > 40 ? interruptionNote(reply) : "";
+        const id = m.id ? String(m.id) : void 0;
+        void runTurn(dx.voice, store, session, m.text + note, void 0, cwd, (c) => dx.send(c, { id, replaces: m.replaces ? String(m.replaces) : void 0 })).then(({ res }) => out({ type: "turn_done", id, finishReason: res?.finishReason ?? "error" })).catch((e) => {
+          log33.error("duplex turn failed", e);
+          out({ type: "turn_done", id, finishReason: "error", error: String(e?.message ?? e) });
+        });
+      }
+    });
+    rl.on("close", () => resolveDone());
+  });
+  await done;
+  for (const t of dx.tasks.values()) if (t.status === "running") dx.cancelTask(t.id);
+  activeTurn?.abort();
+  persist();
+  await closeMcp(mounted);
+}
 function readAllStdin() {
   return new Promise((res) => {
     let data = "";
@@ -19329,6 +19422,11 @@ async function main() {
     worktreeCleanup?.();
     process.exit(ok ? 0 : res?.finishReason === "needs_input" ? 2 : 1);
   }
+  if (args.inputFormat) {
+    await duplexServe(args, ai, cfg, cwd);
+    worktreeCleanup?.();
+    process.exit(0);
+  }
   await repl(args, ai, cfg, cwd);
   worktreeCleanup?.();
 }