@livx.cc/agentx 0.99.27 → 0.99.30

package/dist/{Agent-ChSs1QSx.d.ts → Agent-DC7FEEjF.d.ts}

@@ -1,5 +1,5 @@
 import { IFilesystem } from '@livx.cc/wcli/core';
-import { M as Message, H as HostBridge, A as AgentTool, C as ChatLike, e as MessageContent, U as UserQuestion } from './tools-CJAPSBhS.js';
+import { M as Message, H as HostBridge, A as AgentTool, C as ChatLike, g as MessageContent, U as UserQuestion } from './tools-BZVppx-6.js';
 
 /**
  * Hooks — deterministic interception points around tool execution, run by the
@@ -184,7 +184,7 @@ interface RunResult {
      *  `needs_input` is NOT a failure: the agent hit a decision that was the user's to make with no
      *  human reachable, so it stopped and raised the question (see `question`) instead of guessing.
      *  Answer it and resume the session to continue. */
-    finishReason: 'stop' | 'max_steps' | 'budget' | 'timeout' | 'loop' | 'max_tool_calls' | 'aborted' | 'error' | 'needs_input';
+    finishReason: 'stop' | 'max_steps' | 'budget' | 'timeout' | 'loop' | 'max_tool_calls' | 'aborted' | 'error' | 'needs_input' | 'empty';
     messages: Message[];
     /** The parked question — present iff `finishReason === 'needs_input'`. */
     question?: UserQuestion;
@@ -201,6 +201,14 @@ interface RunResult {
     usageEstimated?: boolean;
     error?: unknown;
 }
+/** What a manual `/compact` actually freed (token estimates, ~4 chars/token). */
+interface CompactResult {
+    tokensBefore: number;
+    tokensAfter: number;
+    target: number;
+    cap: number;
+    removed: number;
+}
 declare class AgentOptions {
     /** Any ai.libx.js AIClient (or a FakeAIClient). */
     ai: ChatLike;
@@ -217,7 +225,8 @@ declare class AgentOptions {
     /** Hard ceiling on accumulated tokens (prompt+completion) across the run; cache READS count at 0.1×
      *  (their real price) so a fat cached context doesn't trip the guard on healthy turns. 0 = unbounded. */
     maxTokens: number;
-    /** Wall-clock ceiling in ms for the whole run. 0 = unbounded. */
+    /** Idle ceiling in ms: max time since the last productive step before the run is killed (a long/active
+     *  step resets it — see runLoop's `lastProgressAt`). Not a whole-run wall clock. 0 = unbounded. */
     timeoutMs: number;
     /** Idle-stall watchdog for a SINGLE streamed model request: abort it if no chunk (text OR reasoning)
      *  arrives for this long. The between-steps `timeoutMs` can't preempt an in-flight `chat()`, so a
@@ -229,15 +238,33 @@ declare class AgentOptions {
     maxToolCalls: number;
     /** External cancellation — abort the loop between steps (e.g. a UI "Cancel" button). */
     signal?: AbortSignal;
+    /** Retry budget for an EMPTY/silent-turn (a delegated-runtime wedge: cursor's warm helper spins then
+     *  returns a content-less end, surfaced as `code:'empty'`/`code:'cursor_silent'`). Tuned WIDER than the
+     *  network-drop budget (fixed 2) because clearing a wedge needs several reap+respawn cycles — each retry
+     *  hits a FRESH cursor session (the adapter evicts the wedged warm helper on the silent-end). Still bounded:
+     *  after exhaustion the turn surfaces `finishReason:'empty'` (non-zero exit), never infinite, never silent.
+     *  Env: AGENTX_EMPTY_RETRIES. */
+    emptyRetries: number;
+    /** Base backoff (ms) between empty-turn retries; grows linearly per attempt (longer than the network
+     *  class's fixed 1s so a wedged helper has time to be reaped/respawned). Env: AGENTX_EMPTY_RETRY_BASE_MS. */
+    emptyRetryBaseMs: number;
     /** 0 = never trim. Otherwise cap the messages sent per turn (system + most recent). */
     maxContextMessages: number;
     /** Note-taking: keep the most-recent N tool-result outputs verbatim; collapse OLDER ones to a one-line
      *  stub in the sent context (the model already consumed them — it can re-Read/re-run). The stored
      *  transcript is never mutated. 0 = keep all verbatim. */
     keepToolOutputs: number;
+    /** How many of the most-recent image-bearing messages get their image REF expanded to real base64 in
+     *  the outgoing request. Older ones (and legacy inline base64) go on the wire as the elision stub. */
+    keepRecentImages: number;
     /** Token-aware backstop (~4 chars/token estimate). After note-taking, drop oldest messages from the
      *  sent context until the estimate is under this ceiling (pairing-safe). 0 = off. */
     maxContextTokens: number;
+    /** The MODEL's context window (tokens) — what the context % is measured against and what `/compact`
+     *  targets 50% of. Filled by the CLI from model metadata; 0 = fall back to 200k. Deliberately NOT
+     *  `maxTokens`: that is the cumulative SPEND kill-switch, and a spend budget must never be able to
+     *  drive destructive compaction (`--max-tokens 50000` would otherwise shred the transcript). */
+    contextWindow: number;
     /** Pagination ceiling for a SINGLE tool result (bytes). A result over this is cropped to page 1 with
      *  a marker telling the model it was cropped (refine the query, or page further). Guards against one
      *  Grep/Read/MCP call blowing the whole context window. 0 = off. Default 60k (~15k tokens). */
@@ -299,8 +326,10 @@ declare class AgentOptions {
     /** Stream tokens from the model. Takes effect only with a `host.notify`; off => current (non-stream) behavior. */
     stream: boolean;
     /** Closure reflex for delegated runtimes (cursor/claude-code): when such a turn ends on a tool call with
-     *  no assistant text after it (the runtime went silent post-work), nudge ONE more step for a brief summary
-     *  of what changed + what's pending — so the turn delivers a wrap-up instead of trailing off mid-narration.
+     *  no assistant text after it (the runtime went silent post-work), nudge ONE more step to ANSWER the user
+     *  from the tool results already in the transcript — so the turn delivers a reply instead of trailing off
+     *  mid-narration. Deliberately not a "summarize what you did" nudge: that produced process reports and
+     *  permission-asking instead of answers (see the nudge text in runLoop).
      *  Fires at most once per run and only for delegated runtimes (native turns never emit the trigger). */
     closeDelegatedTurns: boolean;
     /** Fold the dropped middle of an over-long transcript into a synthetic summary (edge-safe, no LLM). Off => drop-oldest. */
@@ -437,13 +466,16 @@ declare class Agent {
      */
     send(task: MessageContent): Promise<RunResult>;
     /**
-     * Fold the conversation in place (manual `/compact`): keep the system message + the
-     * most-recent window, summarizing the dropped middle (deterministic, no LLM call).
-     * No-op when the transcript already fits. Returns the number of messages removed.
-     * `focus` (e.g. from `/compact keep the API details`) preserves matching lines from the
-     * dropped span verbatim in the summary, instead of losing them to the generic recap.
+     * Fold the conversation in place (manual `/compact`) until it fits a TOKEN budget — not a message
+     * count. Message-count folding alone frees almost nothing when a few recent tool results are huge,
+     * so we escalate: fold the middle into a synthetic recap → elide oversized tool-result bodies in the
+     * retained window → halve the window → drop-oldest backstop. Deterministic, no LLM call.
+     * `focus` (e.g. `/compact keep the API details`) preserves matching lines from the dropped span verbatim.
+     * Returns before/after token estimates so the caller can report honestly (0 freed => say so).
      */
-    compactNow(maxMessages?: number, focus?: string): number;
+    compactNow(maxMessages?: number, focus?: string): CompactResult;
+    /** Drop inline base64 images from older messages so Bun/JSC can reclaim the heap (see contentBytes). */
+    releaseStaleImages(keepRecent?: number): void;
     private runLoop;
     /**
      * Drain a streamed chat() response: emit each text delta to the host
@@ -458,8 +490,16 @@ declare class Agent {
      * `stallMs = 0` disables the timer but still links parent-abort → child so cancellation propagates.
      */
     private armStallWatchdog;
+    /** A clean-stop turn that carries no assistant text AND no tool calls (native or delegated) — a
+     *  non-result the model produced by going silent. Callers retry it rather than report "done". */
+    private isEmptyStop;
     private consumeStream;
     private dispatch;
+    /** `/compact` aims to land the transcript at this fraction of the context window. */
+    private static readonly COMPACT_TARGET;
+    /** THE context-window cap resolution — `/compact`'s budget and the CLI's context footer/warnings both
+     *  route here, so the percentage the user reads and the one compaction targets can never drift. */
+    static contextCap(o: Pick<AgentOptions, 'maxContextTokens' | 'contextWindow' | 'model'> | Partial<AgentOptions>): number;
     private static readonly WRITE_CLASS;
     /** Append an autoTest failure section to a write-class tool result, if configured. */
     private maybeAutoTest;
@@ -474,5 +514,11 @@ declare class Agent {
      */
     trimContext(): Message[];
 }
+/** ~4 chars/token estimate over content + serialized tool_calls. THE estimator — the CLI footer,
+ *  `/context` and `/compact` all route here so what the user sees and what compaction targets can't
+ *  drift apart. Images are weighed AS SENT (`sendBytes`): only the recent window's refs cost their
+ *  file, stale ones cost the stub. Budgeting a ref at full file size while the wire carries a 50-byte
+ *  stub made `/compact` chase a target it could never reach and drop-oldest the conversation away. */
+declare function estimateTokens(m: Message[], keepRecentImages?: number): number;
 
-export { Agent as A, type ChatFragment as C, DEFAULT_MUTATING as D, type Hooks as H, PermissionOptions as P, type ReasoningEffort as R, type ToolUse as T, AgentOptions as a, type Decision as b, PermissionPolicy as c, type PermissionRule as d, type PreToolUseDecision as e, RecordingHooks as f, RecordingLifecycle as g, type RunResult as h, type ToolUseMeta as i, composeHooks as j, planMode as p, reasoningToChatFragment as r };
+export { Agent as A, type ChatFragment as C, DEFAULT_MUTATING as D, type Hooks as H, PermissionOptions as P, type ReasoningEffort as R, type ToolUse as T, AgentOptions as a, type CompactResult as b, type Decision as c, PermissionPolicy as d, type PermissionRule as e, type PreToolUseDecision as f, RecordingHooks as g, RecordingLifecycle as h, type RunResult as i, type ToolUseMeta as j, composeHooks as k, estimateTokens as l, planMode as p, reasoningToChatFragment as r };

package/dist/cli.d.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
-import { H as Hooks, h as RunResult, R as ReasoningEffort, A as Agent } from './Agent-ChSs1QSx.js';
+import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-DC7FEEjF.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
-import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, e as MessageContent } from './tools-CJAPSBhS.js';
+import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, g as MessageContent } from './tools-BZVppx-6.js';
 
 /**
  * On-disk session store for the CLI: each conversation is one JSON file at
@@ -205,8 +205,10 @@ declare function costOf(pricing: {
 } | undefined, promptTokens?: number, completionTokens?: number, cacheCreationTokens?: number, cacheReadTokens?: number, model?: string): number;
 /** Format a USD amount: 2 decimals at $1+, 4 below (agent turns are sub-cent). */
 declare function fmtUsd(n: number): string;
-/** ~4 chars/token estimate over a transcript (matches the Agent's context-budget heuristic). */
-declare function estimateTranscriptTokens(messages: Message[]): number;
+/** ~4 chars/token estimate over a transcript (matches the Agent's context-budget heuristic).
+ *  Weighs images AS SENT (`sendBytes`): only the recent window's refs cost their file; stale ones cost
+ *  the stub — otherwise every old screenshot would stay immortal and fake a "90% full" warning. */
+declare function estimateTranscriptTokens(messages: Message[], keepRecentImages?: number): number;
 /** One-screen session status (model, dir, fs-mode, tools, permission posture, turns/tokens). Pure. */
 declare function formatStatus(s: {
     model: string;
@@ -251,8 +253,9 @@ declare function resolvePermMode(args: {
  *  form is what lets a drag-dropped macOS screenshot ("Screenshot 2026-06-11 at ….png") attach at all.
  *  Bare refs get trailing sentence punctuation stripped (e.g. "@a.ts." / "@a.ts?"). */
 declare function mentionRefs(line: string): string[];
-/** Read `@image.png` mentions from `line` as base64 image content parts (real files under cwd; binary,
- *  so read via node fs — the VFS readFile is utf8). Unreadable/missing images are skipped silently
+/** Read `@image.png` mentions from `line` as image REFERENCE parts — the path, not the payload. The
+ *  base64 is materialized only in the outgoing request (Agent.trimContext → expandImagesForSend), so the
+ *  transcript and session JSON never carry megabytes. Missing/unreadable images are skipped
  *  (expandMentions reports the missing @ref separately). */
 declare function readImageParts(cwd: string, line: string): ContentPart[];
 /** Classify a pasted blob as a file attachment when it's a drag-dropped/typed path to an existing file.
@@ -275,7 +278,7 @@ declare function jsonResult(res: RunResult, session: SessionData): {
     error?: any;
     question?: UserQuestion | undefined;
     ok: boolean;
-    finishReason: "error" | "budget" | "stop" | "max_steps" | "timeout" | "loop" | "max_tool_calls" | "aborted" | "needs_input";
+    finishReason: "error" | "budget" | "stop" | "max_steps" | "timeout" | "loop" | "max_tool_calls" | "aborted" | "needs_input" | "empty";
     text: string;
     steps: number;
     tools: number;