@livx.cc/agentx 0.99.57 → 0.99.59

package/dist/{Agent-CXkPfYX2.d.ts → Agent-DqFJubs5.d.ts}

@@ -1,5 +1,103 @@
 import { IFilesystem } from '@livx.cc/wcli/core';
-import { M as Message, H as HostBridge, A as AgentTool, C as ChatLike, k as JobRegistry, o as MessageContent, U as UserQuestion } from './tools-HsbxgqjF.js';
+import { M as Message, o as MessageContent, H as HostBridge, A as AgentTool, C as ChatLike, k as JobRegistry, U as UserQuestion } from './tools-HsbxgqjF.js';
+
+/**
+ * `--model auto`: per-turn model routing. A classifier (Jev by default — injected, so a regex or
+ * cheap-model classifier can replace it) picks a capability tier — fast | standard | premium — for each user turn (tiers map to any provider's models).
+ *
+ * The MAIN session only ever runs on fast/standard: switching it to premium throws away the prompt cache.
+ * A hard turn is instead OFFLOADED to a premium sub-agent (same child machinery as the `Task` tool):
+ * the main model writes a brief, the last 2 turns ride along verbatim, and the premium answer is appended
+ * to the main transcript as that turn's reply. The premium side-conversation is kept in `state` and
+ * RESUMED (delta + new question only) when the classifier says the turn continues the same thread.
+ *
+ * Classifier failure/timeout ⇒ standard (logged). `state` is plain JSON so a host can persist it
+ * across processes (the CLI stores it in the session, so `-c`/`--resume` keeps the premium thread).
+ */
+
+type Tier = 'fast' | 'standard' | 'premium';
+interface Turn {
+    user: string;
+    assistant: string;
+}
+interface RouteInput {
+    previousModel: 'fast' | 'standard';
+    history: Turn[];
+    next: string;
+    lastOffload?: string;
+}
+/** Classifier output: tier probabilities (+ the raw argmax) and, when asked, P(same thread as last offload). */
+interface Classification {
+    probs: Partial<Record<Tier, number>>;
+    choice: Tier;
+    sameThread?: number;
+}
+type Classifier = (input: RouteInput) => Promise<Classification>;
+interface RouteDecision {
+    tier: Tier;
+    model: string;
+    probs: Partial<Record<Tier, number>>;
+    choice?: Tier;
+    sameThread?: number;
+    offload?: 'fresh' | 'continue';
+    fallback?: string;
+    classifyMs: number;
+}
+interface RouterState {
+    main?: string;
+    offload?: {
+        messages: Message[];
+        mainLen: number;
+        question: string;
+    };
+    offloads?: number;
+    reuses?: number;
+}
+type Usage = NonNullable<RunResult['usage']>;
+declare class ModelRouterOptions {
+    classifier: Classifier;
+    /** Capability tiers → model id (any provider). fast/standard run the main session; premium is only ever an offload. */
+    models: Record<Tier, string>;
+    /** Escalate to a stronger tier when it holds at least this much probability mass (upward bias). */
+    threshold: number;
+    /** P(same thread) at or above which the previous premium side-conversation is resumed. */
+    sameThreadAt: number;
+    classifyTimeoutMs: number;
+    /** Host-supplied pricing (model, usage) → USD, so mixed-model turns are costed per model. */
+    costOf: (model: string, usage?: Usage) => number;
+    /** Step budget for the premium sub-agent. */
+    offloadMaxSteps: number;
+    /** Host-supplied provider options per model (e.g. claude-code's subscription env); applied on every tier switch + the offload child. */
+    providerOptionsFor?: (model: string) => Record<string, unknown> | undefined;
+}
+/** Upward-biased tier pick: premium if P(premium) ≥ th; standard over fast if P(standard)+P(premium) ≥ th. */
+declare function pickTier(c: Classification, th: number): Tier;
+declare class ModelRouter {
+    options?: Partial<ModelRouterOptions> | undefined;
+    state: RouterState;
+    constructor(options?: Partial<ModelRouterOptions> | undefined);
+    private get o();
+    /** Classify one turn. Never throws: classifier failure/timeout ⇒ standard. */
+    decide(transcript: Message[], next: string): Promise<RouteDecision>;
+    /** Run one user turn on `agent` with routing. Returns a RunResult carrying `costUsd` + `routing`. */
+    send(agent: Agent, content: MessageContent): Promise<RunResult>;
+    private offload;
+    /** The main model writes the task brief on its own (cached) context, tools off; the transcript is restored after. */
+    private brief;
+    private use;
+    private spawn;
+}
+/** Default classifier: Jev (TypeSafe). The module is loaded lazily from `jevModule`
+ *  (default `@livx.cc/mcp-jev/jev`, or `$AGENTX_JEV_MODULE`); provider keys come from `env`,
+ *  optionally merged with a dotenv file at `$AGENTX_JEV_ENV`. Any load/eval error ⇒ router falls back. */
+type JevOpts = {
+    jevModule?: string;
+    envFile?: string;
+    provider?: string;
+};
+/** True when Jev can actually run here (module resolves + at least one provider key) — gates `auto` as the default model. */
+declare function jevAvailable(opts?: JevOpts): Promise<boolean>;
+declare function jevClassifier(opts?: JevOpts): Classifier;
 
 /**
  * Hooks — deterministic interception points around tool execution, run by the
@@ -201,6 +299,10 @@ interface RunResult {
     };
     /** True if ANY turn's usage was estimated (provider gave none) rather than exact — lets the UI mark cost `~`. */
     usageEstimated?: boolean;
+    /** Set by a router (`--model auto`) whose turn spans several models: the turn's USD at each model's own rate. */
+    costUsd?: number;
+    /** `--model auto` routing decision for this turn. */
+    routing?: RouteDecision;
     /** Advertised tools the model NAMED in the reply it is handing back while the run's invocation ledger
      *  shows zero calls to them — a fabricated tool use, proven against ground truth rather than guessed
      *  from phrasing. A host can use it to tell the user plainly instead of shipping the invented result.
@@ -630,4 +732,4 @@ declare class Agent {
  *  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 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 };
+export { Agent as A, type ChatFragment as C, DEFAULT_MUTATING as D, type Hooks as H, ModelRouter as M, PermissionOptions as P, type ReasoningEffort as R, type Tier as T, AgentOptions as a, type Classification as b, type Classifier as c, type CompactResult as d, type Decision as e, ModelRouterOptions as f, PermissionPolicy as g, type PermissionRule as h, type PreToolUseDecision as i, RecordingHooks as j, RecordingLifecycle as k, type RouteDecision as l, type RouterState as m, type RunResult as n, type ToolUse as o, type ToolUseMeta as p, composeHooks as q, estimateTokens as r, jevAvailable as s, jevClassifier as t, pickTier as u, planMode as v, reasoningToChatFragment as w };

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-CXkPfYX2.js';
+import { m as RouterState, H as Hooks, n as RunResult, R as ReasoningEffort, A as Agent } from './Agent-DqFJubs5.js';
 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-HsbxgqjF.js';
 
@@ -15,6 +15,8 @@ interface SessionMeta {
     updated: number;
     cwd: string;
     model?: string;
+    /** `-m auto` router state (main model + reusable opus side-conversation). */
+    router?: RouterState;
     turns: number;
     title: string;
     /** Cumulative tokens across all turns in this session (for `/cost`). */
@@ -58,6 +60,13 @@ declare class SessionStore {
     load(id: string): SessionData | undefined;
     /** All sessions' metadata, most-recently-updated first. */
     list(): SessionMeta[];
+    /** Cheap listing — ids from filenames + mtime/size from stat, NO parsing (list() parses every file: 870
+     *  sessions / 157MB took ~150ms+ synchronously). Most-recently-written first. */
+    files(): {
+        id: string;
+        mtime: number;
+        size: number;
+    }[];
     latest(): SessionMeta | undefined;
     /** The most-recently-updated session's full data (single listing pass). */
     latestData(): SessionData | undefined;
@@ -145,6 +154,7 @@ interface Args {
     updateCheck?: boolean;
     update?: boolean;
     listModels?: boolean;
+    autoRoute?: boolean;
 }
 declare function parseArgs(argv: string[]): Args;
 declare function makeHost(format?: 'text' | 'json' | 'stream-json', opts?: {
@@ -203,6 +213,14 @@ declare function costOf(pricing: {
     inputCostPer1K: number;
     outputCostPer1K: number;
 } | undefined, promptTokens?: number, completionTokens?: number, cacheCreationTokens?: number, cacheReadTokens?: number, model?: string): number;
+/** Cost of one turn at `model`'s rate (looks up ai.libx.js pricing). Subscription `claude-code/<alias>` models
+ *  are priced at their API-equivalent Anthropic rate so auto-vs-pinned comparisons stay meaningful. */
+declare function turnCost(model: string, usage?: {
+    promptTokens?: number;
+    completionTokens?: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+}): 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).
@@ -277,6 +295,9 @@ declare function expandMentions(fs: IFilesystem, line: string): Promise<{
 declare function jsonResult(res: RunResult, session: SessionData): {
     error?: any;
     question?: UserQuestion | undefined;
+    sessionId: string;
+    costUsd?: number | undefined;
+    routing?: Record<string, unknown> | undefined;
     text: string;
     steps: number;
     tools: number;
@@ -287,7 +308,6 @@ declare function jsonResult(res: RunResult, session: SessionData): {
         cacheCreationTokens?: number;
         cacheReadTokens?: number;
     } | undefined;
-    sessionId: string;
     providerFinishReason?: string | undefined;
     ok: boolean;
     finishReason: "error" | "budget" | "stop" | "max_steps" | "timeout" | "loop" | "max_tool_calls" | "aborted" | "needs_input" | "empty";
@@ -306,4 +326,4 @@ declare function runTurn(agent: Agent, store: SessionStore, session: SessionData
     res?: RunResult;
 }>;
 
-export { type PermMode, abortActiveTurn, appendMemoryNote, cacheMultipliers, condenseReplay, costOf, estimateTranscriptTokens, expandMentions, exportMarkdown, fmtUsd, formatHistory, formatStatus, formatTranscriptFull, jsonResult, makeHost, mcpMentionResolver, mentionRefs, parseArgs, pastePathClassifier, readImageParts, readMultiline, resolvePermMode, runShellLine, runTurn, setMcpMentionResolver, summarizeResult };
+export { type PermMode, abortActiveTurn, appendMemoryNote, cacheMultipliers, condenseReplay, costOf, estimateTranscriptTokens, expandMentions, exportMarkdown, fmtUsd, formatHistory, formatStatus, formatTranscriptFull, jsonResult, makeHost, mcpMentionResolver, mentionRefs, parseArgs, pastePathClassifier, readImageParts, readMultiline, resolvePermMode, runShellLine, runTurn, setMcpMentionResolver, summarizeResult, turnCost };