@livx.cc/agentx 0.99.120 → 0.99.122

package/dist/{secondChannel-DepBV0Zv.d.ts → secondChannel-BddfVzTp.d.ts}

@@ -260,6 +260,85 @@ declare function planMode(opts?: {
 /** Run several Hooks as one: preToolUse stops at the first block; post/stop all fire. */
 declare function composeHooks(...list: (Hooks | undefined)[]): Hooks;
 
+/**
+ * Two-model modes (ported from Blank #258/#272) — generic, host-agnostic.
+ *
+ * DELEGATE `[planner->worker]` — the (premium) agent model PLANS, a cheaper worker model WRITES.
+ * The planner keeps every read tool plus `Task`/`TaskBatch`, but may not write: a nudge in the prompt
+ * was not enough (Opus, told to delegate, wrote the whole app itself 8 runs of 8). So the rule is
+ * enforced at EXECUTION. Workers inherit this exact toolbelt (children get the parent's tools), so the
+ * one thing that tells a planner call from a worker call is the calling agent's own model, which the
+ * Agent puts on `ToolContext.model`. That is why delegate mode refuses to start when the models are equal.
+ *
+ * ADVISOR `[worker<-advisor]` — the inverse. The cheap model drives with every tool; `Advise` makes a
+ * few short calls to the premium model that see only the request, an optional host snapshot and the
+ * question — never the system prompt or the conversation (Anthropic's advisor tool / Aider's architect).
+ * A prompt rule was not enough here either (Haiku, told to consult, wrote everything with 0 calls), so
+ * the first write waits for one consult.
+ *
+ * Both modes run the second model through the agent's shared `ai`; `meterWorkers` sums every call on
+ * a model other than the agent's own, which the Agent reports as `RunResult.workerUsage`.
+ */
+
+/** Tools that change files — refused for the planner, gated for an advised worker. */
+declare const WRITE_TOOLS: Set<string>;
+/** The planner also loses the shells: either one can write files. */
+declare const PLANNER_BLOCKED: Set<string>;
+declare const PLANNER_REFUSAL = "Refused: you are the planner and do not write files. Delegate the change with Task/TaskBatch (model set to the worker) and give the worker a full spec.";
+declare const PLAN_FIRST = "Refused: check your plan with `Advise` before the first write (files, data shape, the hard parts). Then write.";
+/** A build may consult at most this many times by default: plan + review + one spare. */
+declare const ADVISE_LIMIT = 3;
+type ModeTool = {
+    name: string;
+    run: (...a: any[]) => any;
+};
+/** The worker model when delegate mode can run for this planner, else undefined (why: in the log). */
+declare function delegateWorkerFor(planner: string, worker?: string | false | null): string | undefined;
+/** The advisor model when advisor mode can run for this worker, else undefined. */
+declare function advisorFor(worker: string, advisor?: string | false | null): string | undefined;
+/** Refuse the planner's file-changing tools; a worker (any other `ctx.model`) runs them as usual. */
+declare function delegateTools<T extends ModeTool>(tools: T[], planner: string): T[];
+/** Appended to the PLANNER's system prompt only (workers inherit the host's base prompt). */
+declare function delegatePrompt(worker: string): string;
+/** Appended to the advised worker's system prompt. */
+declare function advisorPrompt(advisor: string): string;
+interface AdvisorSetup {
+    ai: ChatLike;
+    advisor: string;
+    /** The user's request as the advisor should read it (the current turn's text). */
+    request: () => string;
+    /** Host-supplied state the advisor reads NOW (mid-run): files, a diff, a summary. Capped. Default: none. */
+    snapshot?: () => string | Promise<string>;
+    limit?: number;
+}
+/** The `Advise` tool, plus `gate` for the file tools: the first write waits for one consult
+ *  (a failed consult counts — it never blocks the work). */
+type Advisor = {
+    tool: ModeTool & {
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+    gate: <T extends ModeTool>(tools: T[]) => T[];
+    used: () => number;
+};
+declare function makeAdvisor(o: AdvisorSetup): Advisor;
+type ChatUsage = {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+};
+/** Meter the second model's calls: every call on the shared `ai` that names a model other than `main`
+ *  (workers, the advisor). Streams count their LAST usage chunk, as the agent loop does. `model()` is
+ *  the provider's resolved id of the last such call (captured right after it, before `main` overwrites it). */
+declare function meterWorkers<T extends ChatLike>(ai: T, main: string): {
+    ai: T;
+    usage: () => ChatUsage | undefined;
+    model: () => string | undefined;
+    reset: () => void;
+};
+
 /**
  * Normalized reasoning/thinking control → provider-specific request fragment.
  *
@@ -337,6 +416,10 @@ interface RunResult {
      *  ran it"), and on the guard's own success path that sentence is false. Whether a turn needed rescuing
      *  is a telemetry question, and the `log.warn` at the nudge already answers it. */
     fabricatedToolClaims?: string[];
+    /** Delegate/advisor mode: the second model (provider-resolved id when known) and the summed usage of its
+     *  calls this run — NOT included in `usage`, which is the agent's own model. */
+    workerModel?: string;
+    workerUsage?: ChatUsage;
     error?: unknown;
 }
 /** What a manual `/compact` actually freed (token estimates, ~4 chars/token). */
@@ -468,6 +551,19 @@ declare class AgentOptions {
     hooks?: Hooks;
     /** If true: add the `Task` tool so the agent can spawn depth-limited child agents over the VFS. */
     subagents: boolean;
+    /** DELEGATE MODE: `model` plans, `worker` writes. The planner's Write/Edit/MultiEdit/ApplyEdits/bash/Shell are
+     *  refused at execution; Task/TaskBatch are on (maxDepth 1, children default to `worker`) and children get the
+     *  parent's `postToolUse` too. Off when the models are equal or either is cursor/*. Wins over `advisor`. */
+    delegate?: {
+        worker: string;
+    };
+    /** ADVISOR MODE: `model` does the work; an `Advise` tool asks `advisor.model` (≤`limit`, default 3) with only
+     *  the request + `snapshot()` (host state, optional) + the question. The first write waits for one consult. */
+    advisor?: {
+        model: string;
+        limit?: number;
+        snapshot?: () => string | Promise<string>;
+    };
     /** VFS dir of typed-subagent defs (`<dir>/<name>.md`). If set with `subagents`: inject a catalog + enable the `Task` `agentType` param. */
     agentsDir?: string;
     /** Current recursion depth (0 = top-level); spawned children run at depth+1. */
@@ -566,6 +662,9 @@ declare class Agent {
     private ctx;
     private lastTrimNotified;
     private activeTools;
+    private meter?;
+    private modeModel?;
+    private lastTask;
     /** claude-code bridge for agentx-only tools (ccBridge.ts) + the current step's executor it calls. */
     private ccServer?;
     private ccExec?;
@@ -687,6 +786,7 @@ declare class Agent {
     /** Drop inline base64 images from older messages so Bun/JSC can reclaim the heap (see contentBytes). */
     releaseStaleImages(keepRecent?: number): void;
     private runLoop;
+    private loop;
     /**
      * Drain a streamed chat() response: emit each text delta to the host
      * (`{kind:'text_delta'}`) and fold all chunks back into the single
@@ -960,6 +1060,9 @@ declare class SecondChannelOptions {
     /** Duplex v3 (§3 first sound): a bridge skips the decider (the veto stays for backchannels/fillers) and speaks a
      *  canned line at once; a generated one is started at dispatch and used only if it already landed. */
     instantBridge: boolean;
+    /** Duplex v3 §3 late bridge: a turn that expects an answer (not a closer) and got no bridge yet gets one canned bridge
+     *  this long after the user's last word if channel-1 is still silent — the short turns the 0ms rule skips ("Hi"). 0 = off. */
+    lateBridgeMs: number;
     /** No new interim for this long → a pause (hosts may also call onPause). */
     fillerPauseMs: number;
     fillerMinWords: number;
@@ -994,6 +1097,9 @@ declare class SecondChannel {
     private pauseTimer;
     private bcTimer;
     private bridgeTimer;
+    private lateTimer;
+    private late;
+    private lastWordAgo;
     private lastAt;
     private lastKind;
     private live;
@@ -1038,7 +1144,7 @@ declare class SecondChannel {
     /** Channel-1 lifecycle. `queued` = the user's turn was dispatched to the main agent. */
     onAgentState(s: MainState): void;
     /** The user's final line was dispatched to the main agent (its words are the bridge's micro-context). */
-    onUserTurn(text: string): void;
+    onUserTurn(text: string, lastWordAgoMs?: number): void;
     /** The main answer's streamed text (before its audio): channel-1 is responding — no bridge from here on. */
     onMainTokens(text: string): void;
     /** Channel-1's reply text (a delta) — only the plan's context; no state change (hosts without onMainTokens). */
@@ -1061,6 +1167,7 @@ declare class SecondChannel {
     blocked(k: LineKind): string;
     /** Why this turn gets no bridge by rule ('' = it may) — language, a quick/phatic turn, or blocked(). */
     bridgeBlock(): string;
+    private shortTurn;
     private bcTimes;
     private capped;
     /** 0ms rule: the candidate line for this trigger, or silence. */
@@ -1082,4 +1189,4 @@ declare class SecondChannel {
     private say;
 }
 
-export { Agent as A, reasoningToChatFragment as B, type ChannelMode as C, DEFAULT_MUTATING as D, type Gender as G, type Hooks as H, type LineKind as L, ModelRouter as M, PermissionOptions as P, type ReasoningEffort as R, SecondChannel as S, type Tier as T, AgentOptions as a, type ChatFragment as b, type Classification as c, type Classifier as d, type CompactResult as e, type Decider as f, type Decision as g, ModelRouterOptions as h, PermissionPolicy as i, type PermissionRule as j, type PreToolUseDecision as k, RecordingHooks as l, RecordingLifecycle as m, type RouteDecision as n, type RouterState as o, type RunResult as p, SecondChannelOptions as q, type ToolUse as r, type ToolUseMeta as s, claudeCodeDisallowedTools as t, composeHooks as u, estimateTokens as v, jevAvailable as w, jevClassifier as x, pickTier as y, planMode as z };
+export { ADVISE_LIMIT as A, advisorPrompt as B, type ChannelMode as C, DEFAULT_MUTATING as D, claudeCodeDisallowedTools as E, composeHooks as F, type Gender as G, type Hooks as H, delegatePrompt as I, delegateTools as J, delegateWorkerFor as K, type LineKind as L, ModelRouter as M, estimateTokens as N, jevAvailable as O, PLANNER_BLOCKED as P, jevClassifier as Q, type ReasoningEffort as R, SecondChannel as S, type Tier as T, makeAdvisor as U, meterWorkers as V, WRITE_TOOLS as W, pickTier as X, planMode as Y, reasoningToChatFragment as Z, type AdvisorSetup as a, Agent as b, AgentOptions as c, type ChatFragment as d, type ChatUsage as e, type Classification as f, type Classifier as g, type CompactResult as h, type Decider as i, type Decision as j, ModelRouterOptions as k, PLANNER_REFUSAL as l, PLAN_FIRST as m, PermissionOptions as n, PermissionPolicy as o, type PermissionRule as p, type PreToolUseDecision as q, RecordingHooks as r, RecordingLifecycle as s, type RouteDecision as t, type RouterState as u, type RunResult as v, SecondChannelOptions as w, type ToolUse as x, type ToolUseMeta as y, advisorFor as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/agentx",
-  "version": "0.99.120",
+  "version": "0.99.122",
   "description": "Edge-native AI agent runtime — drives a virtual filesystem via any LLM (ai.libx.js). Same bytes run in node, browser, or edge.",
   "type": "module",
   "main": "./dist/index.js",