muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/sub-agent-cap.test.ts

@@ -1,227 +0,0 @@
-import type { ToolSet } from "ai";
-import { describe, expect, it, vi } from "vitest";
-
-import { compressForCap, type SubAgentCapState, wrapToolSetWithCap } from "./sub-agent-cap.js";
-
-function freshState(max: number, dedupEnabled = true): SubAgentCapState {
-  return {
-    cumulative: 0,
-    max,
-    exhausted: false,
-    dedupHits: 0,
-    seenHashes: new Map(),
-    callIndex: 0,
-    dedupEnabled,
-    dedupMinChars: 500,
-    midTierRatio: 0.3,
-    highTierRatio: 0.7,
-    midTierChars: 8_000,
-    highTierChars: 2_000,
-    label: "sub-agent",
-  };
-}
-
-describe("compressForCap", () => {
-  it("passes through small outputs while under 30% budget", () => {
-    const state = freshState(100_000);
-    const out = compressForCap(state, "x".repeat(1_000));
-    expect(out.length).toBe(1_000);
-    expect(state.cumulative).toBe(1_000);
-    expect(state.exhausted).toBe(false);
-  });
-
-  it("trims to ~8k head/tail once over 30% budget", () => {
-    const state = freshState(100_000);
-    state.cumulative = 35_000;
-    const out = compressForCap(state, "y".repeat(40_000));
-    expect(out.length).toBeLessThan(40_000);
-    expect(out).toContain("trimmed by sub-agent cap");
-  });
-
-  it("trims to ~2k head plus 'budget low' warning over 70% budget", () => {
-    const state = freshState(100_000);
-    state.cumulative = 75_000;
-    const out = compressForCap(state, "z".repeat(20_000));
-    expect(out).toContain("finalize work");
-    expect(out.length).toBeLessThan(20_000);
-  });
-
-  it("emits exhausted stub once budget is fully spent", () => {
-    const state = freshState(100_000);
-    state.cumulative = 100_000;
-    state.exhausted = true;
-    const out = compressForCap(state, "w".repeat(10_000));
-    expect(out).toContain("budget exhausted");
-    expect(out).toContain("Summarize findings now");
-  });
-
-  it("dedups identical outputs across calls and returns a pointer", () => {
-    const state = freshState(100_000);
-    const payload = "DUP".repeat(500); // 1_500 chars, above the 500-char min
-    const first = compressForCap(state, payload);
-    expect(first).toBe(payload);
-    expect(state.dedupHits).toBe(0);
-
-    const second = compressForCap(state, payload);
-    expect(second).toContain("dup of call");
-    expect(second).toContain("#1");
-    expect(state.dedupHits).toBe(1);
-    // Cumulative should grow by stub length, NOT full payload length again.
-    expect(state.cumulative).toBeLessThan(payload.length * 2);
-  });
-
-  it("skips dedup for outputs shorter than dedupMinChars", () => {
-    const state = freshState(100_000);
-    state.dedupMinChars = 500;
-    const small = "x".repeat(200);
-    compressForCap(state, small);
-    const out = compressForCap(state, small);
-    expect(out).toBe(small);
-    expect(state.dedupHits).toBe(0);
-  });
-
-  it("dedup can be disabled via opts", () => {
-    const state = freshState(100_000, false);
-    const payload = "Y".repeat(1_000);
-    compressForCap(state, payload);
-    const out = compressForCap(state, payload);
-    expect(out).toBe(payload);
-    expect(state.dedupHits).toBe(0);
-  });
-
-  it("marks exhausted once cumulative reaches max", () => {
-    const state = freshState(10_000);
-    compressForCap(state, "a".repeat(9_000));
-    expect(state.exhausted).toBe(false);
-    compressForCap(state, "a".repeat(5_000));
-    expect(state.exhausted).toBe(true);
-  });
-});
-
-describe("wrapToolSetWithCap", () => {
-  it("wraps execute and tracks cumulative output", async () => {
-    const innerExec = vi.fn(async () => "hello-world");
-    const tools: ToolSet = {
-      sample: {
-        description: "sample",
-        inputSchema: { jsonSchema: { type: "object" } } as never,
-        execute: innerExec,
-      } as ToolSet[string],
-    };
-    const { tools: wrapped, state } = wrapToolSetWithCap(tools, { maxCumulativeChars: 20_000 });
-    expect(wrapped.sample).toBeDefined();
-    const execute = (wrapped.sample as unknown as { execute: (i: unknown) => Promise<unknown> }).execute;
-    const out = await execute({});
-    expect(out).toBe("hello-world");
-    expect(state.cumulative).toBe("hello-world".length);
-    expect(innerExec).toHaveBeenCalledOnce();
-  });
-
-  it("passes through tools without execute", () => {
-    const tools: ToolSet = {
-      bare: { description: "x", inputSchema: {} as never } as ToolSet[string],
-    };
-    const { tools: wrapped } = wrapToolSetWithCap(tools);
-    expect(wrapped.bare).toBe(tools.bare);
-  });
-
-  it("honors custom tier ratios (top-level cap uses 50%/80%)", async () => {
-    let counter = 0;
-    const innerExec = async (): Promise<string> => {
-      counter++;
-      return `${counter}-${"Z".repeat(20_000)}`;
-    };
-    const tools: ToolSet = {
-      sample: {
-        description: "sample",
-        inputSchema: {} as never,
-        execute: innerExec,
-      } as ToolSet[string],
-    };
-    const { tools: wrapped, state } = wrapToolSetWithCap(tools, {
-      maxCumulativeChars: 100_000,
-      midTierRatio: 0.5,
-      highTierRatio: 0.8,
-      label: "top-level",
-    });
-    state.cumulative = 40_000; // 40% — still under 50% → pass-through
-    const execute = (wrapped.sample as unknown as { execute: (i: unknown) => Promise<string> }).execute;
-    const first = await execute({});
-    expect(first.length).toBeGreaterThanOrEqual(20_000); // untrimmed
-    // Now jump to 60% — should trim head/tail. Distinct payload so dedup is bypassed.
-    state.cumulative = 60_000;
-    const second = await execute({});
-    expect(second.length).toBeLessThan(20_000);
-    expect(second).toContain("trimmed by top-level cap");
-  });
-
-  it("budget-exhausted stub uses the configured label", () => {
-    const state = freshState(10_000);
-    state.label = "top-level";
-    state.cumulative = 10_000;
-    state.exhausted = true;
-    const out = compressForCap(state, "x".repeat(1_000));
-    expect(out).toContain("top-level tool budget exhausted");
-  });
-
-  it("compresses object outputs with string `output` field", async () => {
-    const innerExec = async () => ({ success: true, output: "Q".repeat(50_000), extra: 1 });
-    const tools: ToolSet = {
-      file: {
-        description: "file",
-        inputSchema: {} as never,
-        execute: innerExec,
-      } as ToolSet[string],
-    };
-    // Use small budget so the first call already lands in the trim tier.
-    const { tools: wrapped, state } = wrapToolSetWithCap(tools, { maxCumulativeChars: 20_000 });
-    state.cumulative = 7_000; // simulate prior usage in trim tier
-    const execute = (wrapped.file as unknown as { execute: (i: unknown) => Promise<unknown> }).execute;
-    const out = (await execute({})) as { success: boolean; output: string; extra: number };
-    expect(out.success).toBe(true);
-    expect(out.extra).toBe(1);
-    expect(out.output.length).toBeLessThan(50_000);
-    expect(out.output).toContain("trimmed");
-  });
-
-  it("counts MCP content-array text toward the cumulative budget", async () => {
-    // MCP tools return { type: "content", value: [{type:"text", text}, ...] },
-    // not a string or {output}. Previously this shape escaped the cumulative
-    // tracker entirely (cumulative stayed 0), letting many MCP calls blow past
-    // the budget even with the per-call cap in place.
-    const innerExec = async () => ({ type: "content", value: [{ type: "text", text: "M".repeat(5_000) }] });
-    const tools: ToolSet = {
-      mcp_demo__q: { description: "mcp", inputSchema: {} as never, execute: innerExec } as ToolSet[string],
-    };
-    const { tools: wrapped, state } = wrapToolSetWithCap(tools, { maxCumulativeChars: 20_000 });
-    const execute = (wrapped.mcp_demo__q as unknown as { execute: (i: unknown) => Promise<unknown> }).execute;
-    await execute({});
-    expect(state.cumulative).toBe(5_000);
-  });
-
-  it("compresses MCP content-array text parts when the budget is in the trim tier", async () => {
-    const innerExec = async () => ({ type: "content", value: [{ type: "text", text: "N".repeat(50_000) }] });
-    const tools: ToolSet = {
-      mcp_demo__big: { description: "mcp", inputSchema: {} as never, execute: innerExec } as ToolSet[string],
-    };
-    const { tools: wrapped, state } = wrapToolSetWithCap(tools, { maxCumulativeChars: 20_000 });
-    state.cumulative = 7_000; // trim tier
-    const execute = (wrapped.mcp_demo__big as unknown as { execute: (i: unknown) => Promise<unknown> }).execute;
-    const out = (await execute({})) as { type: string; value: Array<{ type: string; text: string }> };
-    expect(out.type).toBe("content");
-    expect(out.value[0]!.text.length).toBeLessThan(50_000);
-    expect(out.value[0]!.text).toContain("trimmed");
-  });
-
-  it("leaves non-text MCP content parts (images) untouched", async () => {
-    const image = { type: "image", data: "BASE64", mediaType: "image/png" };
-    const innerExec = async () => ({ type: "content", value: [image] });
-    const tools: ToolSet = {
-      mcp_demo__img: { description: "mcp", inputSchema: {} as never, execute: innerExec } as ToolSet[string],
-    };
-    const { tools: wrapped } = wrapToolSetWithCap(tools, { maxCumulativeChars: 20_000 });
-    const execute = (wrapped.mcp_demo__img as unknown as { execute: (i: unknown) => Promise<unknown> }).execute;
-    const out = (await execute({})) as { value: unknown[] };
-    expect(out.value[0]).toEqual(image);
-  });
-});

package/src/orchestrator/sub-agent-cap.ts

@@ -1,240 +0,0 @@
-/**
- * Sub-agent cumulative tool-output cap.
- *
- * Background: when the orchestrator delegates work to a `task` sub-agent
- * (runTaskRequest / runTaskRequestBatch), the AI SDK drives an internal
- * tool loop that accumulates *every* tool result into the LLM context for
- * the next iteration. There is no auto-compact inside that loop —
- * `postTurnCompact()` only runs in the top-level orchestrator turn. So
- * one sub-agent reading 4 medium files can balloon the context past 500k
- * billed input tokens (real-world repro: session b58603caceb9).
- *
- * Fix: wrap each tool's `execute` with a cumulative-cost tracker. As the
- * sub-agent burns through its budget, returns are truncated more
- * aggressively — eventually telling the agent "budget low, wrap up" so
- * it stops scheduling more reads and produces its summary.
- *
- * This is per-invocation state: each call to createSubAgentToolCap()
- * returns a fresh wrapper with its own counters. Don't share across
- * sub-agent runs.
- *
- * Tiers (default 120_000 chars cumulative ≈ ~30k tokens):
- *   < 30%   → pass through (A1's 32KB per-call cap already applied)
- *   30-70%  → truncate each new result to 8_000 chars head/tail
- *   70-100% → truncate to 2_000 chars head + "[budget low, finalize work]" note
- *   ≥ 100%  → return error stub that signals the agent to stop expanding scope
- */
-
-import { createHash } from "node:crypto";
-import type { ToolSet } from "ai";
-
-export interface SubAgentCapOptions {
-  /** Total chars of tool output the sub-agent may receive before the cap kicks in fully. */
-  maxCumulativeChars?: number;
-  /**
-   * If true (default), identical tool outputs (by content hash) within the
-   * same sub-agent invocation are returned as a short reference stub on
-   * subsequent occurrences. Cheap way to neutralize a sub-agent that
-   * re-reads the same file or re-runs the same grep.
-   */
-  dedupRepeatOutputs?: boolean;
-  /** Outputs below this length are not worth deduplicating. */
-  dedupMinChars?: number;
-  /**
-   * Ratio at which mid-tier compression (head/tail trim) kicks in. Default
-   * 0.3 for sub-agents (aggressive); top-level orchestrator uses 0.5 so
-   * single-tool turns are not trimmed.
-   */
-  midTierRatio?: number;
-  /**
-   * Ratio at which high-tier compression (head only + "finalize" note)
-   * kicks in. Default 0.7 for sub-agents; top-level uses 0.8.
-   */
-  highTierRatio?: number;
-  /**
-   * Char target for mid-tier compression (head/tail trim). Default 8_000.
-   */
-  midTierChars?: number;
-  /**
-   * Char target for high-tier compression. Default 2_000.
-   */
-  highTierChars?: number;
-  /** Identifier surfaced in budget-exhaustion stubs (for debugging). Default "sub-agent". */
-  label?: string;
-}
-
-const DEFAULT_MAX_CUMULATIVE_CHARS = 120_000;
-const DEFAULT_DEDUP_MIN_CHARS = 500;
-const DEFAULT_MID_TIER_RATIO = 0.3;
-const DEFAULT_HIGH_TIER_RATIO = 0.7;
-const DEFAULT_MID_TIER_CHARS = 8_000;
-const DEFAULT_HIGH_TIER_CHARS = 2_000;
-
-export interface SubAgentCapState {
-  /** Running sum of characters returned to the sub-agent so far. */
-  cumulative: number;
-  /** Configured ceiling. */
-  max: number;
-  /** True once `cumulative >= max` (sub-agent should wrap up). */
-  exhausted: boolean;
-  /** Number of duplicate-output detections (telemetry / tests). */
-  dedupHits: number;
-  /** Internal: short-hash → first call index, for "see call #N" pointers. */
-  seenHashes: Map<string, number>;
-  /** Internal: call counter for stable pointers. */
-  callIndex: number;
-  /** Internal: feature flags from options. */
-  dedupEnabled: boolean;
-  dedupMinChars: number;
-  midTierRatio: number;
-  highTierRatio: number;
-  midTierChars: number;
-  highTierChars: number;
-  label: string;
-}
-
-function trimHeadTail(text: string, target: number, label: string): string {
-  if (text.length <= target) return text;
-  const half = Math.floor(target / 2);
-  return `${text.slice(0, half)}\n\n... [${text.length - target} chars trimmed by ${label} cap] ...\n\n${text.slice(-half)}`;
-}
-
-function trimHead(text: string, target: number, label: string): string {
-  if (text.length <= target) return text;
-  return `${text.slice(0, target)}\n\n... [${text.length - target} chars trimmed — ${label} budget low; finalize work] ...`;
-}
-
-function shortHash(text: string): string {
-  return createHash("sha1").update(text).digest("hex").slice(0, 12);
-}
-
-export function compressForCap(state: SubAgentCapState, raw: string): string {
-  if (state.exhausted) {
-    return `[${state.label} tool budget exhausted (${state.cumulative}/${state.max} chars). Further tool calls will return this stub. Summarize findings now and return.]`;
-  }
-  state.callIndex += 1;
-
-  // Dedup pass — if we've already returned this exact output, replace with a
-  // pointer. Cheap protection against an agent that re-reads the same file or
-  // re-runs the same grep mid-loop.
-  if (state.dedupEnabled && raw.length >= state.dedupMinChars) {
-    const hash = shortHash(raw);
-    const firstSeen = state.seenHashes.get(hash);
-    if (firstSeen !== undefined) {
-      state.dedupHits += 1;
-      // F4 — short marker (~50 chars vs ~150). Hash and length are nice-to-
-      // have but the LLM only needs "this is a known duplicate of call #N".
-      const stub = `[dup of call #${firstSeen} — reuse it]`;
-      state.cumulative += stub.length;
-      return stub;
-    }
-    state.seenHashes.set(hash, state.callIndex);
-  }
-
-  const ratio = state.cumulative / state.max;
-  let out: string;
-  if (ratio >= state.highTierRatio) {
-    out = trimHead(raw, state.highTierChars, state.label);
-  } else if (ratio >= state.midTierRatio) {
-    out = trimHeadTail(raw, state.midTierChars, state.label);
-  } else {
-    out = raw;
-  }
-  state.cumulative += out.length;
-  if (state.cumulative >= state.max) state.exhausted = true;
-  return out;
-}
-
-function compressResult(state: SubAgentCapState, raw: unknown): unknown {
-  if (typeof raw === "string") {
-    return compressForCap(state, raw);
-  }
-  if (raw && typeof raw === "object") {
-    const obj = raw as Record<string, unknown>;
-    if (typeof obj.output === "string") {
-      return { ...obj, output: compressForCap(state, obj.output) };
-    }
-    // MCP tool result shape: { type: "content", value: [{type:"text", text}, ...] }.
-    // Without this branch the whole payload escaped the cumulative tracker —
-    // its text never counted toward the budget and was never compressed, so
-    // many MCP calls could blow past the cap. Thread each text part through
-    // compressForCap (counts + compresses + dedups); leave non-text parts
-    // (images/media) intact so base64 isn't corrupted.
-    if (obj.type === "content" && Array.isArray(obj.value)) {
-      const value = obj.value.map((part) => {
-        if (
-          part &&
-          typeof part === "object" &&
-          (part as { type?: unknown }).type === "text" &&
-          typeof (part as { text?: unknown }).text === "string"
-        ) {
-          return { ...(part as object), text: compressForCap(state, (part as { text: string }).text) };
-        }
-        return part;
-      });
-      return { ...obj, value };
-    }
-  }
-  return raw;
-}
-
-function wrapInternal(tools: ToolSet, state: SubAgentCapState): ToolSet {
-  const wrapped: ToolSet = {};
-  for (const [name, tool] of Object.entries(tools)) {
-    const t = tool as Record<string, unknown>;
-    const innerExecute = t.execute as ((input: unknown, ctx?: unknown) => unknown) | undefined;
-    if (!innerExecute) {
-      wrapped[name] = tool;
-      continue;
-    }
-    // Spread the original tool object to preserve description, inputSchema, type, etc.
-    wrapped[name] = {
-      ...(tool as object),
-      execute: async (input: unknown, ctx?: unknown) => {
-        const result = await innerExecute(input, ctx);
-        return compressResult(state, result);
-      },
-    } as ToolSet[string];
-  }
-  return wrapped;
-}
-
-/**
- * Wrap a ToolSet so every tool's execute() is intercepted and its output is
- * subjected to the cumulative cap. Original tool objects are not mutated.
- *
- * Returns { tools, state, rewrap } — `rewrap` lets you re-wrap an expanded
- * tool set later (e.g. after merging in MCP tools) while sharing the same
- * cumulative state.
- */
-export function wrapToolSetWithCap(
-  tools: ToolSet,
-  opts: SubAgentCapOptions = {},
-): {
-  tools: ToolSet;
-  state: SubAgentCapState;
-  rewrap: (next: ToolSet) => ToolSet;
-} {
-  const state: SubAgentCapState = {
-    cumulative: 0,
-    max: Math.max(20_000, opts.maxCumulativeChars ?? DEFAULT_MAX_CUMULATIVE_CHARS),
-    exhausted: false,
-    dedupHits: 0,
-    seenHashes: new Map(),
-    callIndex: 0,
-    dedupEnabled: opts.dedupRepeatOutputs ?? true,
-    dedupMinChars: opts.dedupMinChars ?? DEFAULT_DEDUP_MIN_CHARS,
-    midTierRatio: opts.midTierRatio ?? DEFAULT_MID_TIER_RATIO,
-    highTierRatio: opts.highTierRatio ?? DEFAULT_HIGH_TIER_RATIO,
-    midTierChars: opts.midTierChars ?? DEFAULT_MID_TIER_CHARS,
-    highTierChars: opts.highTierChars ?? DEFAULT_HIGH_TIER_CHARS,
-    label: opts.label ?? "sub-agent",
-  };
-  return {
-    tools: wrapInternal(tools, state),
-    state,
-    rewrap: (next: ToolSet) => wrapInternal(next, state),
-  };
-}
-
-export const SUB_AGENT_DEFAULT_BUDGET_CHARS = DEFAULT_MAX_CUMULATIVE_CHARS;

package/src/orchestrator/sub-agent-model-tier.ts

@@ -1,58 +0,0 @@
-/**
- * Tier policy for picking the model of a mechanical/delegated task within a turn.
- *
- * The parent (top) model decides WHAT to do; the focused sub-task that follows
- * rarely needs the top premium model. Each task kind declares a tier preference,
- * resolved against the CURRENT provider only — we never cross providers here to
- * avoid billing surprises (a stray key) and keychain complexity. If no model at
- * a preferred tier exists on the provider, we fall through to the next tier and
- * finally to the parent model, so a premium-only provider sees no change.
- *
- * Kinds:
- *  - compact / title : pure mechanical text ops → cheapest first.
- *  - explore         : read-only research → balanced is plenty.
- *  - general         : delegated multi-step execution → balanced (the parent
- *                      already did the hard thinking); falls back to premium.
- *  - verify          : validation/verification → premium first; rigor matters
- *                      more than cost here, so we do NOT downgrade by default.
- */
-import { getModelByTier } from "../models/registry.js";
-
-export type ModelTaskKind = "compact" | "explore" | "general" | "title" | "verify";
-
-export const TASK_TIER_PREFS: Record<ModelTaskKind, Array<"fast" | "balanced" | "premium">> = {
-  compact: ["fast", "balanced"],
-  title: ["fast", "balanced"],
-  explore: ["balanced", "fast"],
-  // general sub-agents downgrade to balanced (was premium-first) — the top
-  // model already planned the delegation; the focused execution doesn't need
-  // premium. Premium remains the fallback so premium-only providers are unaffected.
-  general: ["balanced", "premium"],
-  // verify keeps premium-first: a downgrade here would weaken the very check it
-  // exists to perform. Mirrors council `verify` role preference.
-  verify: ["premium", "balanced"],
-};
-
-/** getModelByTier signature, injectable for testing. */
-export type TierLookup = (
-  tier: "fast" | "balanced" | "premium",
-  preferProvider?: string,
-) => { id: string; provider: string } | undefined;
-
-/**
- * Resolve the model id for a task kind on a given provider. Walks the tier
- * preference list, accepting only same-provider matches, and falls back to
- * `fallbackModelId` (the parent model) when nothing matches.
- */
-export function resolveModelForTask(
-  task: ModelTaskKind,
-  providerId: string,
-  fallbackModelId: string,
-  lookup: TierLookup = getModelByTier as TierLookup,
-): string {
-  for (const tier of TASK_TIER_PREFS[task] ?? ["balanced"]) {
-    const m = lookup(tier, providerId);
-    if (m?.provider === providerId) return m.id;
-  }
-  return fallbackModelId;
-}