@livx.cc/agentx 0.99.58 → 0.99.60

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as AgentOptions, H as Hooks, i as RunResult, A as Agent } from './Agent-CXkPfYX2.js';
-export { C as ChatFragment, b as CompactResult, D as DEFAULT_MUTATING, c as Decision, P as PermissionOptions, d as PermissionPolicy, e as PermissionRule, f as PreToolUseDecision, R as ReasoningEffort, g as RecordingHooks, h as RecordingLifecycle, T as ToolUse, j as ToolUseMeta, k as composeHooks, l as estimateTokens, p as planMode, r as reasoningToChatFragment } from './Agent-CXkPfYX2.js';
+import { a as AgentOptions, H as Hooks, n as RunResult, A as Agent } from './Agent-DbqXQy5q.js';
+export { C as ChatFragment, b as Classification, c as Classifier, d as CompactResult, D as DEFAULT_MUTATING, e as Decision, M as ModelRouter, f as ModelRouterOptions, P as PermissionOptions, g as PermissionPolicy, h as PermissionRule, i as PreToolUseDecision, R as ReasoningEffort, j as RecordingHooks, k as RecordingLifecycle, l as RouteDecision, m as RouterState, T as Tier, o as ToolUse, p as ToolUseMeta, q as composeHooks, r as estimateTokens, s as jevAvailable, t as jevClassifier, u as pickTier, v as planMode, w as reasoningToChatFragment } from './Agent-DbqXQy5q.js';
 export { MODEL_ALIASES, ModelSwitch, ResolveModelSwitchOpts, modelShortLabel, resolveModelAlias, resolveModelSwitch } from './models.js';
 import { IFilesystem, FileMetadata } from '@livx.cc/wcli/core';
 export { CommandExecutor, FileMetadata, IFilesystem, IndexedDbFilesystem, MemFilesystem, registerHeadlessCommands } from '@livx.cc/wcli/core';

package/dist/index.js

@@ -3391,6 +3391,7 @@ function resolveModelAlias(input) {
   const slash = input.indexOf("/");
   const prefix = slash === -1 ? "" : input.slice(0, slash + 1);
   const rest = slash === -1 ? input : input.slice(slash + 1);
+  if (prefix === "claude-code/") return input;
   return prefix + (MODEL_ALIASES[rest.toLowerCase()] ?? rest);
 }
 function modelProvider(model) {
@@ -10465,6 +10466,250 @@ Another agent just implemented the above. Independently check the CURRENT state
   }
 };
 
+// src/modelRouter.ts
+init_llm();
+init_logging();
+var log22 = forComponent("ModelRouter");
+var ModelRouterOptions = class {
+  classifier = jevClassifier();
+  /** 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. */
+  sameThreadAt = 0.5;
+  classifyTimeoutMs = 1e4;
+  /** Host-supplied pricing (model, usage) → USD, so mixed-model turns are costed per model. */
+  costOf = () => 0;
+  /** Step budget for the premium sub-agent. */
+  offloadMaxSteps = 40;
+  /** Host-supplied provider options per model (e.g. claude-code's subscription env); applied on every tier switch + the offload child. */
+  providerOptionsFor;
+};
+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 "basic";
+}
+function textTurns(msgs) {
+  const out = [];
+  for (const m of msgs) {
+    if (m.role === "user") {
+      const t = contentText(m.content).trim();
+      if (t) out.push({ user: t, assistant: "" });
+    } else if (m.role === "assistant" && out.length) {
+      const t = contentText(m.content).trim();
+      if (t) out[out.length - 1].assistant = (out[out.length - 1].assistant + "\n" + t).trim();
+    }
+  }
+  return out;
+}
+var fmtTurns = (ts) => ts.map((t) => `USER: ${t.user}
+ASSISTANT: ${t.assistant || "(no text reply)"}`).join("\n\n");
+var addUsage = (a, b) => {
+  if (!a) return b;
+  if (!b) return a;
+  return {
+    promptTokens: a.promptTokens + b.promptTokens,
+    completionTokens: a.completionTokens + b.completionTokens,
+    totalTokens: a.totalTokens + b.totalTokens,
+    cacheCreationTokens: (a.cacheCreationTokens ?? 0) + (b.cacheCreationTokens ?? 0),
+    cacheReadTokens: (a.cacheReadTokens ?? 0) + (b.cacheReadTokens ?? 0)
+  };
+};
+var ModelRouter = class {
+  constructor(options) {
+    this.options = options;
+    this.options = { ...new ModelRouterOptions(), ...options };
+  }
+  options;
+  state = {};
+  get o() {
+    return this.options;
+  }
+  /** Classify one turn. Never throws: classifier failure/timeout ⇒ standard. */
+  async decide(transcript, next) {
+    const o = this.o;
+    const main = this.state.main === o.models.basic ? "basic" : "standard";
+    const input = {
+      previousModel: main,
+      history: textTurns(transcript).slice(-4).map((t) => ({ user: t.user.slice(0, 1500), assistant: t.assistant.slice(0, 1500) })),
+      next,
+      lastOffload: this.state.offload?.question
+    };
+    const t0 = performance.now();
+    let d;
+    try {
+      let timer;
+      const c = await Promise.race([
+        o.classifier(input),
+        new Promise((_, rej) => {
+          timer = setTimeout(() => rej(new Error(`classifier timeout ${o.classifyTimeoutMs}ms`)), o.classifyTimeoutMs);
+        })
+      ]).finally(() => clearTimeout(timer));
+      const tier = pickTier(c, o.threshold);
+      d = { tier, model: o.models[tier], probs: c.probs, choice: c.choice, sameThread: c.sameThread, classifyMs: Math.round(performance.now() - t0) };
+      if (tier === "premium") d.offload = this.state.offload && (c.sameThread ?? 0) >= o.sameThreadAt ? "continue" : "fresh";
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      log22.warn(`classifier failed, falling back to standard: ${msg}`);
+      d = { tier: "standard", model: o.models.standard, probs: {}, fallback: msg, classifyMs: Math.round(performance.now() - t0) };
+    }
+    log22.info(`route ${d.tier}${d.offload ? `(${d.offload})` : ""} \xB7 argmax=${d.choice ?? "-"} \xB7 p=${JSON.stringify(d.probs)}${d.sameThread != null ? ` \xB7 same=${d.sameThread.toFixed(2)}` : ""} \xB7 ${d.classifyMs}ms`);
+    return d;
+  }
+  /** Run one user turn on `agent` with routing. Returns a RunResult carrying `costUsd` + `routing`. */
+  async send(agent, content) {
+    const o = this.o;
+    const text = contentText(content);
+    const d = await this.decide(agent.transcript, text);
+    if (d.tier !== "premium") {
+      this.use(agent, this.state.main = d.model);
+      const res = await agent.send(content);
+      return { ...res, costUsd: o.costOf(d.model, res.usage), routing: d };
+    }
+    this.use(agent, this.state.main ??= o.models.standard);
+    return this.offload(agent, content, text, d);
+  }
+  async offload(agent, content, text, d) {
+    const o = this.o, main = this.state.main;
+    const prev = this.state.offload;
+    const cont = d.offload === "continue" && prev && prev.mainLen <= agent.transcript.length;
+    let briefUsage, prompt;
+    if (cont) {
+      const delta = textTurns(agent.transcript.slice(prev.mainLen));
+      prompt = `Follow-up in the same thread.${delta.length ? ` Since your last answer the main conversation continued:
+
+${fmtTurns(delta)}
+` : ""}
+
+New request:
+${text}`;
+    } else {
+      const b = await this.brief(agent, text);
+      briefUsage = b.usage;
+      const last2 = textTurns(agent.transcript).slice(-2);
+      prompt = `You are handling a hard turn delegated by the main agent of an ongoing session. You do NOT see its conversation \u2014 only this brief. Do the work with your tools, then reply to the user directly (your reply is shown as the session's answer).
+
+--- brief from the main agent ---
+${b.text}
+
+${last2.length ? `--- last turns (verbatim) ---
+${fmtTurns(last2)}
+
+` : ""}--- current user request (verbatim) ---
+${text}`;
+    }
+    const child = this.spawn(agent);
+    const res = cont ? (child.transcript = prev.messages, await child.send(prompt)) : await child.run(prompt);
+    this.state.offloads = (this.state.offloads ?? 0) + 1;
+    if (cont) this.state.reuses = (this.state.reuses ?? 0) + 1;
+    const answer = res.text || `(premium sub-agent finished with no reply; finishReason=${res.finishReason})`;
+    agent.transcript.push({ role: "user", content }, { role: "assistant", content: answer });
+    this.state.offload = { messages: child.transcript, mainLen: agent.transcript.length, question: text };
+    log22.info(`offload ${cont ? "continue" : "fresh"} done \xB7 ${res.finishReason} \xB7 ${res.steps} steps`);
+    const costUsd = o.costOf(main, briefUsage) + o.costOf(o.models.premium, res.usage);
+    return { ...res, text: answer, messages: agent.transcript, usage: addUsage(briefUsage, res.usage), costUsd, routing: d };
+  }
+  /** The main model writes the task brief on its own (cached) context, tools off; the transcript is restored after. */
+  async brief(agent, text) {
+    const snap = agent.transcript.slice();
+    const { host, toolChoice, maxSteps } = agent.options;
+    Object.assign(agent.options, { host: void 0, toolChoice: "none", maxSteps: 1 });
+    try {
+      const r = await agent.send(`[router] The next request is being delegated to a stronger sub-agent that will NOT see this conversation. Write the self-contained brief you would hand it (<=200 words): the task, the relevant facts/files/decisions established so far, constraints. Output only the brief.
+
+The request:
+${text}`);
+      return { text: r.text.trim() || text, usage: r.usage };
+    } catch (e) {
+      log22.warn(`brief failed, sending the raw request: ${e instanceof Error ? e.message : String(e)}`);
+      return { text };
+    } finally {
+      agent.transcript = snap;
+      Object.assign(agent.options, { host, toolChoice, maxSteps });
+    }
+  }
+  use(agent, model) {
+    agent.options.model = model;
+    if (this.o.providerOptionsFor) agent.options.providerOptions = this.o.providerOptionsFor(model);
+  }
+  spawn(agent) {
+    const a = agent.options;
+    const co = childOptionsFor(
+      { ai: a.ai, model: a.model, fs: a.fs, tools: a.tools, systemPrompt: a.systemPrompt, hooks: a.hooks, maxSteps: this.o.offloadMaxSteps, traceDir: a.traceDir, providerOptionsFor: this.o.providerOptionsFor },
+      a.fs,
+      a.depth ?? 0,
+      a.maxDepth ?? 2,
+      void 0,
+      this.o.models.premium
+    );
+    if (typeof co === "string") throw new Error(co);
+    co.signal = a.signal;
+    return new Agent(co);
+  }
+};
+var JEV_KEYS = ["AI_GATEWAY_API_KEY", "OPENROUTER_API_KEY", "TYPESAFE_API_KEY"];
+async function loadJev(opts) {
+  const mod = await import(opts.jevModule ?? process.env.AGENTX_JEV_MODULE ?? "@livx.cc/mcp-jev/jev");
+  const env = { ...process.env };
+  const file = opts.envFile ?? process.env.AGENTX_JEV_ENV;
+  if (file) {
+    const { readFileSync: readFileSync3 } = await import("fs");
+    for (const l of readFileSync3(file, "utf8").split("\n")) {
+      const m = l.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*?)\s*$/);
+      if (m && !env[m[1]]) env[m[1]] = m[2].replace(/^['"]|['"]$/g, "");
+    }
+  }
+  return { mod, env };
+}
+async function jevAvailable(opts = {}) {
+  try {
+    const { env } = await loadJev(opts);
+    return JEV_KEYS.some((k) => env[k]?.trim());
+  } catch (e) {
+    log22.debug(`jev unavailable: ${e instanceof Error ? e.message : String(e)}`);
+    return false;
+  }
+}
+function jevClassifier(opts = {}) {
+  let router;
+  const load = async () => {
+    const { mod, env } = await loadJev(opts);
+    return new mod.JevRouter({ env });
+  };
+  return async (input) => {
+    const jev = await (router ??= load().catch((e) => {
+      router = void 0;
+      throw e;
+    }));
+    const questions = [{
+      id: "tier",
+      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: {
+        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."
+      }
+    }];
+    if (input.lastOffload) questions.push({
+      id: "sameThread",
+      type: "boolean",
+      instructions: "Does nextUserMessage continue the same line of work as lastOffload (the previous hard request, handled by a specialist) \u2014 a follow-up, refinement or next step of it \u2014 rather than a new, unrelated topic?"
+    });
+    const state = { previousModel: input.previousModel, history: input.history, nextUserMessage: input.next, ...input.lastOffload ? { lastOffload: input.lastOffload } : {} };
+    const r = await jev.evaluate({ state, questions }, opts.provider);
+    const a = r.answers.tier;
+    const map = (k) => k;
+    const probs = {};
+    for (const [k, v] of Object.entries(a.probabilities ?? {})) probs[map(k)] = v;
+    const st = r.answers.sameThread;
+    return { choice: map(a.choice), probs, sameThread: st ? st.probability ?? (st.value ? 1 : 0) : void 0 };
+  };
+}
+
 // src/mcp.ts
 function toResult(result) {
   if (result == null) return { text: "" };
@@ -10730,6 +10975,8 @@ export {
   MEMORY_PROMPT,
   MODEL_ALIASES,
   MemFilesystem3 as MemFilesystem,
+  ModelRouter,
+  ModelRouterOptions,
   MountFilesystem,
   NodeDiskFilesystem,
   OverlayFilesystem,
@@ -10791,6 +11038,8 @@ export {
   imagePart,
   imageRefPart,
   imageRefResult,
+  jevAvailable,
+  jevClassifier,
   lessonCapture,
   loadAgents,
   loadCommands,
@@ -10825,6 +11074,7 @@ export {
   parseCron,
   parseDdgHtml,
   parseImageRef,
+  pickTier,
   planMode,
   raceAttempts,
   readTool,