@livx.cc/agentx 0.99.59 → 0.99.60

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

@@ -3,9 +3,9 @@ import { M as Message, o as MessageContent, H as HostBridge, A as AgentTool, C a
 
 /**
  * `--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).
+ * cheap-model classifier can replace it) picks a capability tier — basic | 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.
+ * The MAIN session only ever runs on basic/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
@@ -15,13 +15,13 @@ import { M as Message, o as MessageContent, H as HostBridge, A as AgentTool, C a
  * across processes (the CLI stores it in the session, so `-c`/`--resume` keeps the premium thread).
  */
 
-type Tier = 'fast' | 'standard' | 'premium';
+type Tier = 'basic' | 'standard' | 'premium';
 interface Turn {
     user: string;
     assistant: string;
 }
 interface RouteInput {
-    previousModel: 'fast' | 'standard';
+    previousModel: 'basic' | 'standard';
     history: Turn[];
     next: string;
     lastOffload?: string;
@@ -56,7 +56,7 @@ interface RouterState {
 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. */
+    /** Capability tiers → model id (any provider). basic/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;
@@ -70,7 +70,7 @@ declare class ModelRouterOptions {
     /** 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. */
+/** Upward-biased tier pick: premium if P(premium) ≥ th; standard over basic if P(standard)+P(premium) ≥ th. */
 declare function pickTier(c: Classification, th: number): Tier;
 declare class ModelRouter {
     options?: Partial<ModelRouterOptions> | undefined;

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { m as RouterState, H as Hooks, n as RunResult, R as ReasoningEffort, A as Agent } from './Agent-DqFJubs5.js';
+import { m as RouterState, H as Hooks, n as RunResult, R as ReasoningEffort, A as Agent } from './Agent-DbqXQy5q.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';
 

package/dist/cli.js

@@ -10669,8 +10669,8 @@ init_logging();
 var log21 = forComponent("ModelRouter");
 var ModelRouterOptions = class {
   classifier = jevClassifier();
-  /** Capability tiers → model id (any provider). fast/standard run the main session; premium is only ever an offload. */
-  models = { fast: "anthropic/claude-haiku-4-5-20251001", standard: "anthropic/claude-sonnet-4-6", premium: "anthropic/claude-opus-5-5" };
+  /** Capability tiers → model id (any provider). basic/standard run the main session; premium is only ever an offload. */
+  models = { basic: "anthropic/claude-haiku-4-5-20251001", standard: "anthropic/claude-sonnet-4-6", premium: "anthropic/claude-opus-5-5" };
   /** Escalate to a stronger tier when it holds at least this much probability mass (upward bias). */
   threshold = 0.25;
   /** P(same thread) at or above which the previous premium side-conversation is resumed. */
@@ -10687,7 +10687,7 @@ function pickTier(c, th) {
   const o = c.probs.premium ?? 0, s = c.probs.standard ?? 0;
   if (o >= th || c.choice === "premium") return "premium";
   if (c.choice === "standard" || s + o >= th) return "standard";
-  return "fast";
+  return "basic";
 }
 function textTurns(msgs) {
   const out = [];
@@ -10728,7 +10728,7 @@ var ModelRouter = class {
   /** Classify one turn. Never throws: classifier failure/timeout ⇒ standard. */
   async decide(transcript, next) {
     const o = this.o;
-    const main2 = this.state.main === o.models.fast ? "fast" : "standard";
+    const main2 = this.state.main === o.models.basic ? "basic" : "standard";
     const input = {
       previousModel: main2,
       history: textTurns(transcript).slice(-4).map((t) => ({ user: t.user.slice(0, 1500), assistant: t.assistant.slice(0, 1500) })),
@@ -10886,7 +10886,7 @@ function jevClassifier(opts = {}) {
       type: "choice",
       instructions: "Pick the CHEAPEST model that will handle the NEXT assistant turn correctly for this coding-agent conversation. Staying on previousModel keeps its prompt cache warm; switch only when the next turn clearly needs more (or much less) capability.",
       criteria: {
-        fast: "Trivial: commands, lookups, acknowledgements, commits, mechanical single-file edits, short rewrites.",
+        basic: "Trivial: commands, lookups, acknowledgements, commits, mechanical single-file edits, short rewrites.",
         standard: "Standard engineering: features, bounded refactors, reviews, tests, following a clear trace, summarising.",
         premium: "Hard: root-causing subtle/intermittent bugs, concurrency, security semantics, architecture trade-offs, quantitative reasoning."
       }