@cjhyy/code-shell 0.1.0-alpha.3 → 0.1.5

package/dist/chunk-5ECBT4YA.js

@@ -0,0 +1,450 @@
+import {
+  init_esm_shims
+} from "./chunk-MD32R22I.js";
+
+// src/settings/manager.ts
+init_esm_shims();
+import {
+  readFileSync,
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  renameSync,
+  copyFileSync
+} from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+
+// src/settings/schema.ts
+init_esm_shims();
+import { z } from "zod";
+var SettingsSchema = z.object({
+  agent: z.object({
+    // Use z.string() instead of z.enum() to allow custom presets registered via registerPreset()
+    preset: z.string().default("terminal-coding"),
+    enabledBuiltinTools: z.array(z.string()).default([]),
+    disabledBuiltinTools: z.array(z.string()).default([]),
+    customSystemPrompt: z.string().optional(),
+    appendSystemPrompt: z.string().optional()
+  }).default({}),
+  /**
+   * Primary source of truth for the active model is settings.activeKey
+   * (points at models[].key). settings.model is a derived mirror of that
+   * entry kept in sync for legacy boot paths (cli/main.ts, repl.ts, etc.)
+   * which read provider/name/apiKey/baseUrl directly. Writers must update
+   * both — appendOnboardingResult does this in one shot.
+   */
+  activeKey: z.string().optional(),
+  /**
+   * Toggle background auto-update. When true (default), code-shell checks
+   * npm for newer versions and — if the npm global prefix is writable —
+   * installs the update in the background on process exit so the next
+   * launch picks it up.
+   * Can also be disabled via env var `DISABLE_AUTOUPDATER=1`.
+   */
+  autoUpdates: z.boolean().default(true),
+  model: z.object({
+    provider: z.string().default("openai"),
+    name: z.string().default("anthropic/claude-opus-4-6"),
+    apiKey: z.string().optional(),
+    baseUrl: z.string().default("https://openrouter.ai/api/v1"),
+    temperature: z.number().min(0).max(2).default(0.3),
+    maxTokens: z.number().default(8192)
+  }).default({}),
+  providers: z.array(
+    z.object({
+      key: z.string(),
+      label: z.string().optional(),
+      kind: z.enum([
+        "openai",
+        "anthropic",
+        "deepseek",
+        "xai",
+        "mistral",
+        "groq",
+        "google",
+        "openrouter",
+        "ollama",
+        "custom"
+      ]),
+      baseUrl: z.string(),
+      apiKey: z.string().optional(),
+      protocol: z.enum(["openai-compat", "anthropic-style"]).optional(),
+      modelsPath: z.string().optional()
+    })
+  ).default([]),
+  models: z.array(
+    z.object({
+      key: z.string(),
+      label: z.string().optional(),
+      providerKey: z.string().optional(),
+      model: z.string(),
+      maxOutputTokens: z.number().optional(),
+      maxContextTokens: z.number().optional(),
+      /**
+       * Which LLM client to use ("openai" or "anthropic"). New name —
+       * the legacy field is `provider`, which we still accept and
+       * fold into `protocol` below so old configs keep working.
+       * NOT the brand/vendor — that's providerKey above.
+       */
+      protocol: z.string().optional(),
+      provider: z.string().optional(),
+      baseUrl: z.string().optional(),
+      apiKey: z.string().optional()
+    }).transform((m) => {
+      const effective = m.protocol ?? m.provider;
+      return {
+        ...m,
+        protocol: effective,
+        provider: effective
+      };
+    })
+  ).default([]),
+  permissions: z.object({
+    defaultMode: z.enum(["default", "acceptEdits", "dontAsk", "bypassPermissions", "auto", "plan"]).default("default"),
+    rules: z.array(
+      z.object({
+        tool: z.string(),
+        argsPattern: z.record(z.string()).optional(),
+        decision: z.enum(["allow", "deny", "ask"]),
+        reason: z.string().optional()
+      })
+    ).default([])
+  }).default({}),
+  context: z.object({
+    maxTokens: z.number().default(2e5),
+    compactAtRatio: z.number().default(0.6),
+    summarizeAtRatio: z.number().default(0.8)
+  }).default({}),
+  session: z.object({
+    storageDir: z.string().optional(),
+    maxHistory: z.number().default(100)
+  }).default({}),
+  mcpServers: z.record(
+    z.object({
+      name: z.string(),
+      command: z.string().optional(),
+      args: z.array(z.string()).optional(),
+      env: z.record(z.string()).optional(),
+      url: z.string().optional(),
+      transport: z.enum(["stdio", "sse", "streamable-http", "inprocess"]).optional(),
+      headers: z.record(z.string()).optional()
+    })
+  ).default({}),
+  instructions: z.object({
+    fileName: z.string().default("CODESHELL.md"),
+    scanDirs: z.array(z.string()).default([]),
+    compatFileNames: z.array(z.string()).default(["CLAUDE.md", "AGENTS.md"]),
+    ignoreGitBoundary: z.boolean().default(false)
+  }).default({}),
+  arena: z.object({
+    participants: z.array(
+      z.union([
+        // Short form: just a model pool key
+        z.string(),
+        // Full form: explicit config (backward compat)
+        z.object({
+          name: z.string(),
+          model: z.string(),
+          provider: z.string().optional(),
+          apiKey: z.string().optional(),
+          baseUrl: z.string().optional()
+        })
+      ])
+    ).default([])
+  }).default({}),
+  search: z.object({
+    provider: z.enum(["serper", "tavily", "searxng"]).default("serper"),
+    apiKey: z.string().optional(),
+    baseUrl: z.string().optional()
+  }).default({}),
+  output: z.object({
+    format: z.enum(["text", "json", "jsonl", "stream-json"]).default("text")
+  }).default({})
+}).passthrough();
+function validateSettings(raw) {
+  return SettingsSchema.parse(raw);
+}
+
+// src/cli/migrate-models.ts
+init_esm_shims();
+var BASEURL_KIND_PATTERNS = [
+  [/deepseek\.com/i, "deepseek"],
+  [/anthropic\.com/i, "anthropic"],
+  [/openai\.com/i, "openai"],
+  [/x\.ai/i, "xai"],
+  [/mistral\.ai/i, "mistral"],
+  [/groq\.com/i, "groq"],
+  [/generativelanguage\.googleapis/i, "google"],
+  [/openrouter\.ai/i, "openrouter"],
+  [/localhost:11434|127\.0\.0\.1:11434/i, "ollama"]
+];
+function inferKind(baseUrl) {
+  if (!baseUrl) return "custom";
+  for (const [re, kind] of BASEURL_KIND_PATTERNS) {
+    if (re.test(baseUrl)) return kind;
+  }
+  return "custom";
+}
+function makeFingerprint(m) {
+  return `${m.provider ?? ""}|${m.baseUrl ?? ""}|${m.apiKey ?? ""}`;
+}
+function deriveKey(base, used) {
+  if (!used.has(base)) return base;
+  for (let i = 2; ; i++) {
+    const candidate = `${base}-${i}`;
+    if (!used.has(candidate)) return candidate;
+  }
+}
+function deriveProviderModelKey(providerKind, modelId, used) {
+  const slash = modelId.lastIndexOf("/");
+  const base = slash >= 0 ? modelId.slice(slash + 1) : modelId;
+  const prefix = providerKind.toLowerCase();
+  const candidate = base.toLowerCase().startsWith(`${prefix}-`) ? base : `${prefix}-${base}`;
+  if (!used.has(candidate)) return candidate;
+  for (let i = 2; ; i++) {
+    const k = `${candidate}-${i}`;
+    if (!used.has(k)) return k;
+  }
+}
+function migrateModels(input) {
+  if (input.models.length === 0) {
+    return {
+      providers: input.providers,
+      models: [],
+      changed: false
+    };
+  }
+  const hasProvidersSection = input.providers.length > 0;
+  const keyCounts = /* @__PURE__ */ new Map();
+  for (const m of input.models) keyCounts.set(m.key, (keyCounts.get(m.key) ?? 0) + 1);
+  const needsMigration = input.models.some(
+    (m) => !m.providerKey || (keyCounts.get(m.key) ?? 0) > 1
+  );
+  if (!needsMigration) {
+    return {
+      providers: input.providers,
+      models: input.models.map((m) => ({
+        key: m.key,
+        label: m.label,
+        providerKey: m.providerKey ?? "",
+        model: m.model,
+        maxOutputTokens: m.maxOutputTokens,
+        maxContextTokens: m.maxContextTokens,
+        provider: m.provider,
+        baseUrl: m.baseUrl,
+        apiKey: m.apiKey
+      })),
+      changed: false
+    };
+  }
+  const fingerprintToKey = /* @__PURE__ */ new Map();
+  const newProviders = [];
+  const usedProviderKeys = new Set(input.providers.map((p) => p.key));
+  for (const p of input.providers) {
+    const fp = `${""}|${p.baseUrl}|${p.apiKey ?? ""}`;
+    fingerprintToKey.set(fp, p.key);
+  }
+  for (const m of input.models) {
+    const fp = makeFingerprint(m);
+    const existingByUrl = input.providers.find((p) => p.baseUrl === (m.baseUrl ?? ""));
+    if (existingByUrl) {
+      fingerprintToKey.set(fp, existingByUrl.key);
+      continue;
+    }
+    if (fingerprintToKey.has(fp)) continue;
+    const kind = inferKind(m.baseUrl);
+    const key = deriveKey(kind, usedProviderKeys);
+    usedProviderKeys.add(key);
+    fingerprintToKey.set(fp, key);
+    newProviders.push({
+      key,
+      kind,
+      baseUrl: m.baseUrl ?? "",
+      apiKey: m.apiKey
+    });
+  }
+  const usedModelKeys = /* @__PURE__ */ new Set();
+  const newModels = input.models.map((m) => {
+    const providerKey = fingerprintToKey.get(makeFingerprint(m));
+    const collides = (keyCounts.get(m.key) ?? 0) > 1;
+    let key = m.key;
+    if (collides) {
+      const kind = inferKind(m.baseUrl);
+      key = deriveProviderModelKey(kind, m.model, usedModelKeys);
+    }
+    if (usedModelKeys.has(key)) {
+      const kind = inferKind(m.baseUrl);
+      key = deriveProviderModelKey(kind, m.model, usedModelKeys);
+    }
+    usedModelKeys.add(key);
+    return {
+      key,
+      label: m.label,
+      providerKey,
+      provider: m.provider,
+      model: m.model,
+      baseUrl: m.baseUrl,
+      apiKey: m.apiKey,
+      maxOutputTokens: m.maxOutputTokens,
+      maxContextTokens: m.maxContextTokens
+    };
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = newModels.filter((m) => {
+    const fp = `${m.key}|${m.model}`;
+    if (seen.has(fp)) return false;
+    seen.add(fp);
+    return true;
+  });
+  return {
+    providers: hasProvidersSection ? [...input.providers, ...newProviders] : newProviders,
+    models: deduped,
+    changed: true
+  };
+}
+
+// src/settings/manager.ts
+function userHome() {
+  return process.env.HOME ?? homedir();
+}
+var SettingsManager = class {
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  sources = [];
+  merged = null;
+  /**
+   * Load settings from all sources.
+   */
+  load(flagOverrides) {
+    this.sources = [];
+    this.loadJsonFile(join(userHome(), ".code-shell", "settings.managed.json"), "managed", 0);
+    this.loadJsonFile(join(userHome(), ".code-shell", "settings.json"), "user", 1);
+    this.loadJsonFile(join(userHome(), ".claude", "settings.json"), "user", 1);
+    this.loadJsonFile(join(this.cwd, ".code-shell", "settings.json"), "project", 2);
+    this.loadJsonFile(join(this.cwd, ".claude", "settings.json"), "project", 2);
+    this.loadJsonFile(join(this.cwd, ".code-shell", "settings.local.json"), "local", 3);
+    this.loadJsonFile(join(this.cwd, ".claude", "settings.local.json"), "local", 3);
+    if (flagOverrides && Object.keys(flagOverrides).length > 0) {
+      this.sources.push({ name: "flag", priority: 4, data: flagOverrides });
+    }
+    this.sources.sort((a, b) => a.priority - b.priority);
+    const raw = this.deepMerge();
+    const userPath = join(userHome(), ".code-shell", "settings.json");
+    if (existsSync(userPath)) {
+      try {
+        const userRaw = JSON.parse(readFileSync(userPath, "utf-8"));
+        const result = migrateModels({
+          providers: userRaw.providers ?? [],
+          models: userRaw.models ?? []
+        });
+        if (result.changed) {
+          copyFileSync(userPath, `${userPath}.bak`);
+          const migrated = {
+            ...userRaw,
+            providers: result.providers,
+            models: result.models
+          };
+          writeFileSync(userPath, JSON.stringify(migrated, null, 2), "utf-8");
+          const userSource = this.sources.find((s) => s.name === "user");
+          if (userSource) userSource.data = migrated;
+          const remerged = this.deepMerge();
+          this.merged = validateSettings(remerged);
+          return this.merged;
+        }
+      } catch {
+      }
+    }
+    this.merged = validateSettings(raw);
+    return this.merged;
+  }
+  /**
+   * Get current effective settings.
+   */
+  get() {
+    if (!this.merged) return this.load();
+    return this.merged;
+  }
+  /**
+   * Invalidate cached merge.
+   */
+  invalidate() {
+    this.merged = null;
+  }
+  /**
+   * Persist a single setting (dotted key path) to the user-level config file
+   * at ~/.code-shell/settings.json. Other sources (project / local /
+   * managed) are intentionally untouched: writing back to project/local
+   * would surprise version control, and managed is read-only.
+   *
+   * The merged cache is invalidated so the next get() picks up the change.
+   */
+  saveUserSetting(key, value) {
+    const path = join(userHome(), ".code-shell", "settings.json");
+    let current = {};
+    if (existsSync(path)) {
+      try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          current = parsed;
+        }
+      } catch {
+      }
+    }
+    const parts = key.split(".");
+    let target = current;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const seg = parts[i];
+      const next = target[seg];
+      if (!next || typeof next !== "object" || Array.isArray(next)) {
+        target[seg] = {};
+      }
+      target = target[seg];
+    }
+    target[parts[parts.length - 1]] = value;
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(current, null, 2), "utf-8");
+    renameSync(tmp, path);
+    this.invalidate();
+  }
+  loadJsonFile(path, name, priority) {
+    if (!existsSync(path)) return;
+    try {
+      const content = readFileSync(path, "utf-8");
+      const data = JSON.parse(content);
+      if (typeof data === "object" && data !== null) {
+        this.sources.push({ name, priority, data });
+      }
+    } catch {
+    }
+  }
+  deepMerge() {
+    let result = {};
+    for (const source of this.sources) {
+      result = merge(result, source.data);
+    }
+    return result;
+  }
+};
+function merge(base, override) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === null) {
+      delete result[key];
+    } else if (typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && !Array.isArray(result[key]) && result[key] !== null) {
+      result[key] = merge(result[key], value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export {
+  SettingsSchema,
+  validateSettings,
+  SettingsManager
+};

package/dist/{chunk-YD7XTI7T.cjs → chunk-6QVAYW7C.cjs}

@@ -1,8 +1,8 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
 
-var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+var _chunkKS3RYAYLcjs = require('./chunk-KS3RYAYL.cjs');
 
 // src/context/token-counter.ts
 function estimateStringTokens(text) {
@@ -48,10 +48,10 @@ function estimateBlockTokens(block) {
   return tokens;
 }
 var RATIOS;
-var init_token_counter = _chunkIJSHQGMPcjs.__esm.call(void 0, {
+var init_token_counter = _chunkKS3RYAYLcjs.__esm.call(void 0, {
   "src/context/token-counter.ts"() {
     "use strict";
-    _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+    _chunkKS3RYAYLcjs.init_cjs_shims.call(void 0, );
     RATIOS = {
       english: 4,
       // ~4 chars per token for English prose
@@ -69,7 +69,8 @@ var init_token_counter = _chunkIJSHQGMPcjs.__esm.call(void 0, {
 
 // src/context/compaction.ts
 var compaction_exports = {};
-_chunkIJSHQGMPcjs.__export.call(void 0, compaction_exports, {
+_chunkKS3RYAYLcjs.__export.call(void 0, compaction_exports, {
+  COMPACTABLE_TOOL_NAMES: () => COMPACTABLE_TOOL_NAMES,
   adjustIndexToPreserveAPIInvariants: () => adjustIndexToPreserveAPIInvariants,
   applySummaryCompaction: () => applySummaryCompaction,
   applyToolResultBudget: () => applyToolResultBudget,
@@ -143,35 +144,108 @@ function windowCompact(messages, keepLastN) {
   if (startIndex <= 1) return messages;
   return [messages[0], ...messages.slice(startIndex)];
 }
-function microcompact(messages, keepRecentN = 3) {
-  let toolResultCount = 0;
-  const indices = [];
+function buildToolUseIdToNameMap(messages) {
+  const map = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id && block.name) {
+        map.set(block.id, block.name);
+      }
+    }
+  }
+  return map;
+}
+function summarizeToolCallArgs(toolName, input) {
+  if (!input || typeof input !== "object") return "";
+  const pick = (keys) => {
+    const parts = [];
+    for (const key of keys) {
+      const v = input[key];
+      if (typeof v === "string" && v.length > 0) {
+        parts.push(`${key}=${v.length > 80 ? v.slice(0, 77) + "..." : v}`);
+      }
+    }
+    return parts.join(" ");
+  };
+  switch (toolName) {
+    case "Read":
+    case "Write":
+    case "Edit":
+    case "NotebookEdit":
+      return pick(["file_path", "path", "notebook_path"]);
+    case "Glob":
+    case "Grep":
+      return pick(["pattern", "path", "glob"]);
+    case "Bash":
+    case "PowerShell":
+    case "REPL":
+      return pick(["command"]);
+    case "WebFetch":
+    case "WebSearch":
+      return pick(["url", "query"]);
+    default: {
+      const json = JSON.stringify(input);
+      return json.length > 100 ? json.slice(0, 97) + "..." : json;
+    }
+  }
+}
+function microcompact(messages, options = {}) {
+  const keepRecentN = _nullishCoalesce(options.keepRecentN, () => ( 5));
+  const compactable = _nullishCoalesce(options.compactableTools, () => ( COMPACTABLE_TOOL_NAMES));
+  const idToName = buildToolUseIdToNameMap(messages);
+  const idToInput = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id) {
+        idToInput.set(block.id, block.input);
+      }
+    }
+  }
+  let compactableRoundCount = 0;
+  const indicesToTouch = [];
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
-    if (Array.isArray(msg.content)) {
-      const hasToolResult = msg.content.some((b) => b.type === "tool_result");
-      if (hasToolResult) {
-        toolResultCount++;
-        if (toolResultCount > keepRecentN) {
-          indices.push(i);
-        }
-      }
+    if (!Array.isArray(msg.content)) continue;
+    const hasEligible = msg.content.some(
+      (b) => b.type === "tool_result" && b.tool_use_id != null && compactable.has(_nullishCoalesce(idToName.get(b.tool_use_id), () => ( ""))) && typeof b.content === "string" && !b.content.startsWith("[Old tool result cleared")
+    );
+    if (!hasEligible) continue;
+    compactableRoundCount++;
+    if (compactableRoundCount > keepRecentN) {
+      indicesToTouch.push(i);
     }
   }
-  if (indices.length === 0) return messages;
-  return messages.map((msg, i) => {
-    if (!indices.includes(i)) return msg;
-    if (!Array.isArray(msg.content)) return msg;
+  if (indicesToTouch.length === 0) return messages;
+  const touchSet = new Set(indicesToTouch);
+  const clearedToolNames = /* @__PURE__ */ new Set();
+  let clearedBlocks = 0;
+  const result = messages.map((msg, i) => {
+    if (!touchSet.has(i) || !Array.isArray(msg.content)) return msg;
     return {
       ...msg,
       content: msg.content.map((block) => {
-        if (block.type === "tool_result") {
-          return { ...block, content: "[Old tool result content cleared]" };
-        }
-        return block;
+        if (block.type !== "tool_result" || !block.tool_use_id) return block;
+        const toolName = idToName.get(block.tool_use_id);
+        if (!toolName || !compactable.has(toolName)) return block;
+        if (typeof block.content !== "string") return block;
+        if (block.content.startsWith("[Old tool result cleared")) return block;
+        const argsSummary = summarizeToolCallArgs(toolName, idToInput.get(block.tool_use_id));
+        const fingerprint = argsSummary ? `[Old tool result cleared \u2014 ${toolName} ${argsSummary}]` : `[Old tool result cleared \u2014 ${toolName}]`;
+        clearedToolNames.add(toolName);
+        clearedBlocks++;
+        return { ...block, content: fingerprint };
       })
     };
   });
+  if (clearedBlocks > 0) {
+    _optionalChain([options, 'access', _ => _.onClear, 'optionalCall', _2 => _2({
+      clearedRounds: indicesToTouch.length,
+      toolNames: [...clearedToolNames].sort()
+    })]);
+  }
+  return result;
 }
 function applyToolResultBudget(messages, maxTotalChars = 1e5) {
   return messages.map((msg) => {
@@ -200,9 +274,10 @@ function applyToolResultBudget(messages, maxTotalChars = 1e5) {
     const newContent = msg.content.map((block, i) => {
       if (!toTruncate.has(i)) return block;
       const preview = typeof block.content === "string" ? block.content.slice(0, 500) : "";
+      const sizeKb = (block.content.length / 1e3).toFixed(0);
       return {
         ...block,
-        content: `Output too large (${(block.content.length / 1e3).toFixed(0)}KB). Full output saved to session transcript. Use Read tool to view the source file if needed.
+        content: `Output too large (${sizeKb}KB) \u2014 truncated to fit the per-message budget. Re-run the originating tool if you need the full output.
 
 Preview (first 500 chars):
 ${preview}`
@@ -325,10 +400,22 @@ function extractReferencedFilePaths(messages) {
   }
   return [...paths];
 }
-var init_compaction = _chunkIJSHQGMPcjs.__esm.call(void 0, {
+var COMPACTABLE_TOOL_NAMES;
+var init_compaction = _chunkKS3RYAYLcjs.__esm.call(void 0, {
   "src/context/compaction.ts"() {
-    _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+    _chunkKS3RYAYLcjs.init_cjs_shims.call(void 0, );
     init_token_counter();
+    COMPACTABLE_TOOL_NAMES = exports.COMPACTABLE_TOOL_NAMES = /* @__PURE__ */ new Set([
+      "Read",
+      "Glob",
+      "Grep",
+      "Bash",
+      "PowerShell",
+      "NotebookEdit",
+      "WebFetch",
+      "WebSearch",
+      "REPL"
+    ]);
   }
 });
 
@@ -347,4 +434,5 @@ var init_compaction = _chunkIJSHQGMPcjs.__esm.call(void 0, {
 
 
 
-exports.estimateTokens = estimateTokens; exports.adjustIndexToPreserveAPIInvariants = adjustIndexToPreserveAPIInvariants; exports.snipCompact = snipCompact; exports.windowCompact = windowCompact; exports.microcompact = microcompact; exports.applyToolResultBudget = applyToolResultBudget; exports.truncateToolResult = truncateToolResult; exports.buildSummarizationPrompt = buildSummarizationPrompt; exports.applySummaryCompaction = applySummaryCompaction; exports.groupMessagesByApiRound = groupMessagesByApiRound; exports.dropOldestRounds = dropOldestRounds; exports.extractReferencedFilePaths = extractReferencedFilePaths; exports.compaction_exports = compaction_exports; exports.init_compaction = init_compaction;
+
+exports.estimateTokens = estimateTokens; exports.adjustIndexToPreserveAPIInvariants = adjustIndexToPreserveAPIInvariants; exports.snipCompact = snipCompact; exports.windowCompact = windowCompact; exports.COMPACTABLE_TOOL_NAMES = COMPACTABLE_TOOL_NAMES; exports.microcompact = microcompact; exports.applyToolResultBudget = applyToolResultBudget; exports.truncateToolResult = truncateToolResult; exports.buildSummarizationPrompt = buildSummarizationPrompt; exports.applySummaryCompaction = applySummaryCompaction; exports.groupMessagesByApiRound = groupMessagesByApiRound; exports.dropOldestRounds = dropOldestRounds; exports.extractReferencedFilePaths = extractReferencedFilePaths; exports.compaction_exports = compaction_exports; exports.init_compaction = init_compaction;

package/dist/{chunk-SCDKLTN3.js → chunk-6S4BJ65N.js}

@@ -2,13 +2,13 @@ import {
   ContextLimitError,
   LLMError,
   LLMRateLimitError
-} from "./chunk-FUOKLKR2.js";
+} from "./chunk-SFXHZSRF.js";
 import {
   logger
-} from "./chunk-ZRVPCXI7.js";
+} from "./chunk-BXCY2FSE.js";
 import {
   init_esm_shims
-} from "./chunk-DI7RDLOS.js";
+} from "./chunk-MD32R22I.js";
 
 // src/llm/client-base.ts
 init_esm_shims();
@@ -45,7 +45,8 @@ var LLMClientBase = class _LLMClientBase {
     totalTokens: 0,
     requestCount: 0
   };
-  recordUsage(usage) {
+  recordUsage(usage, options) {
+    if (options?.recordUsage === false) return;
     this.usage.records.push(usage);
     this.usage.totalPromptTokens += usage.promptTokens;
     this.usage.totalCompletionTokens += usage.completionTokens;

package/dist/{chunk-ZLPJJZUW.js → chunk-76HYEPDM.js}

@@ -1,9 +1,9 @@
 import {
   SessionError
-} from "./chunk-FUOKLKR2.js";
+} from "./chunk-SFXHZSRF.js";
 import {
   init_esm_shims
-} from "./chunk-DI7RDLOS.js";
+} from "./chunk-MD32R22I.js";
 
 // src/session/session-manager.ts
 init_esm_shims();