@cjhyy/code-shell 0.3.0 → 0.5.0-rc.2

package/dist/cli/migrate-models.d.ts

@@ -1,45 +0,0 @@
-/**
- * One-shot migration of legacy flat models[] into providers[] + models[].
- *
- * Pure function — takes a snapshot, returns the new snapshot plus a flag.
- * The caller (settings load path) is responsible for writing settings.json
- * and the .bak backup.
- */
-import type { ProviderConfig } from "../llm/provider-catalog.js";
-interface LegacyModel {
-    key: string;
-    label?: string;
-    provider?: string;
-    baseUrl?: string;
-    apiKey?: string;
-    model: string;
-    maxOutputTokens?: number;
-    maxContextTokens?: number;
-    providerKey?: string;
-}
-export interface MigrationInput {
-    providers: ProviderConfig[];
-    models: LegacyModel[];
-}
-export interface MigrationOutput {
-    providers: ProviderConfig[];
-    models: Array<{
-        key: string;
-        label?: string;
-        providerKey: string;
-        model: string;
-        /**
-         * Self-describing legacy fields. Kept (rather than stripped) so model
-         * entries stay valid standalone — the engine can read credentials
-         * straight off the entry without a ProviderCatalog round-trip.
-         */
-        provider?: string;
-        baseUrl?: string;
-        apiKey?: string;
-        maxOutputTokens?: number;
-        maxContextTokens?: number;
-    }>;
-    changed: boolean;
-}
-export declare function migrateModels(input: MigrationInput): MigrationOutput;
-export {};

package/dist/cli/onboarding.d.ts

@@ -1,189 +0,0 @@
-/**
- * Onboarding data layer — provider catalog, env detection, key validation,
- * settings persistence. The interactive flow itself is rendered by Ink
- * (see src/ui/components/OnboardingPrompt.tsx); this module only exposes
- * pure(-ish) helpers it consumes, so there's a single input stack.
- */
-export interface OnboardingResult {
-    /**
-     * Pool alias key (e.g. "deepseek-v4-pro"). The engine uses this to switch
-     * the active model — callers should NOT re-derive an alias from `model`
-     * (the old modelKey() helper folded multiple model ids to one key, which
-     * silently shadowed entries in the pool).
-     */
-    key: string;
-    provider: string;
-    model: string;
-    apiKey: string;
-    baseUrl: string;
-}
-export interface ProviderDef {
-    id: string;
-    name: string;
-    envKey: string;
-    provider: string;
-    baseUrl: string;
-    keyUrl: string;
-    keyPrefix: string;
-    /**
-     * The catalog of model IDs to register for this provider. The first
-     * entry doubles as the zero-config default — auto-activated when the
-     * user boots with just an env key (no onboarding). Users override by
-     * picking in the wizard or running `/model`.
-     */
-    models: string[];
-    /** When true, skip API key prompt (e.g. local providers like Ollama). */
-    noKey?: boolean;
-}
-export declare const PROVIDERS: ProviderDef[];
-/**
- * Resolve the model list a provider should expose right now. For
- * OpenRouter this comes from the snapshot; for direct providers it
- * stays hardcoded (snapshot doesn't carry their native IDs).
- */
-export declare function resolveProviderModels(provider: ProviderDef): string[];
-export interface DetectedEnvKey {
-    provider: ProviderDef;
-    envKey: string;
-    apiKey: string;
-}
-/**
- * Scan environment for known provider API keys.
- * Returns one entry per provider that has its envKey set.
- */
-export declare function detectEnvKeys(): DetectedEnvKey[];
-/** Mask a key for display: "sk-517f...b594" */
-export declare function maskKey(key: string): string;
-/**
- * Find a provider definition that matches a given API key.
- * Checks key prefix first, then env var match, then baseUrl.
- */
-export declare function detectProviderFromApiKey(apiKey: string, baseUrl?: string): ProviderDef | undefined;
-export declare function validateApiKey(baseUrl: string, apiKey: string): Promise<boolean>;
-/**
- * Resolve an API key from the canonical fallback chain.
- * Priority: 1) command-line option  2) settings.json  3) all provider env vars
- */
-export declare function resolveApiKey(optionsApiKey?: string, settingsApiKey?: string): string | undefined;
-/**
- * Look up a previously-persisted API key for a given provider in
- * ~/.code-shell/settings.json. Matches by baseUrl (each ProviderDef.baseUrl
- * is unique, while `provider` is a generic kind like "openai" shared across
- * multiple endpoints).
- *
- * Returns the first match found in: settings.models[] (preferred — newer),
- * then settings.model (legacy top-level). undefined when nothing matches.
- */
-export declare function findSavedKeyForProvider(provider: ProviderDef): {
-    apiKey: string;
-    baseUrl: string;
-} | undefined;
-/**
- * Return the list of model IDs previously saved under this provider
- * (matched by baseUrl). Used by the onboarding wizard to pre-populate the
- * "model pool" step with the user's prior choices instead of resetting to
- * just the provider's first model.
- */
-export declare function loadSavedModelsForProvider(provider: ProviderDef): string[];
-export declare function hasApiKey(): boolean;
-/**
- * Resolve a model's max-output-token budget. Lookup order:
- *   1. KNOWN_MAX_OUTPUT (covers direct providers like Anthropic/DeepSeek
- *      whose IDs aren't in the OpenRouter snapshot)
- *   2. OpenRouter snapshot (covers `vendor/model` style IDs)
- *   3. undefined — caller falls back to its own default
- *
- * Returns undefined (not 0) when nothing is known, so callers can use
- * `?? defaultValue` semantics.
- */
-export declare function resolveMaxOutput(model: string): number | undefined;
-/**
- * Resolve a model's context window size. Lookup order:
- *   1. KNOWN_CONTEXT_WINDOWS (covers direct providers like DeepSeek)
- *   2. OpenRouter snapshot (covers `vendor/model` style IDs)
- *   3. undefined — unknown
- */
-export declare function resolveContextWindow(model: string): number | undefined;
-/**
- * Derive a pool key in `provider-model` form. Single source of truth for
- * model alias generation — replaces the old modelKey() function which
- * folded same-family models to one key (e.g. v4-flash and v4-pro both
- * collapsed to "deepseek"), causing the pool to silently shadow entries.
- *
- *   ("deepseek", "deepseek-v4-pro")  → "deepseek-v4-pro"
- *   ("openai",   "openai/gpt-5")      → "openai-gpt-5"
- *   ("anthropic","claude-opus-4-7")   → "anthropic-claude-opus-4-7"
- *
- * If the model id already starts with `<provider>-` (e.g. "deepseek-v4-pro"
- * under provider "deepseek"), the prefix isn't duplicated.
- *
- * `used` is a set of already-taken keys; collisions are resolved with a
- * `-2`, `-3`, ... suffix.
- */
-export declare function deriveModelPoolKey(providerKind: string, modelId: string, used?: string[]): string;
-/**
- * Build model pool entries from a provider's model list.
- */
-export declare function buildModelPool(provider: ProviderDef, apiKey: string): Array<{
-    key: string;
-    label: string;
-    provider: string;
-    model: string;
-    baseUrl: string;
-    apiKey: string;
-    maxOutputTokens?: number;
-    maxContextTokens?: number;
-}>;
-export declare function modelDisplayName(model: string): string;
-export declare function saveSettings(result: OnboardingResult, providerDef?: ProviderDef, poolModels?: string[]): void;
-/**
- * Append-only persistence for the new ProviderModelFlow-based onboarding.
- *
- * Writes the new shape:
- *   - settings.activeKey      — primary source of truth for active model
- *   - settings.models[]       — self-describing entries (key, provider,
- *                                model, baseUrl, apiKey, maxOutput, maxContext)
- *   - settings.providers[]    — credential source for the wizard
- *   - settings.model.*        — legacy mirror of the active entry, kept in
- *                                sync so legacy boot paths (cli/main.ts,
- *                                repl.ts, run.ts) keep working without
- *                                each having to learn about activeKey
- *
- * Append-only: never removes existing entries. To start over use /logout.
- * Writes atomically via tmp+rename.
- */
-export declare function appendOnboardingResult(opts: {
-    /** Alias key the engine should switch to after writing. Matches one of addedModels[].key. */
-    activeKey: string;
-    /** Active entry's fields, used to mirror into the legacy settings.model.* block. */
-    activeMirror: {
-        provider: string;
-        model: string;
-        apiKey: string;
-        baseUrl: string;
-    };
-    addedProvider?: {
-        key: string;
-        label?: string;
-        kind: string;
-        baseUrl: string;
-        apiKey?: string;
-        protocol?: string;
-        modelsPath?: string;
-    };
-    addedModels: Array<{
-        key: string;
-        label?: string;
-        providerKey?: string;
-        /** LLM client/protocol ("openai"/"anthropic"). New canonical name. */
-        protocol?: string;
-        /** Legacy mirror of `protocol`. Both are written so legacy readers keep working. */
-        provider?: string;
-        model: string;
-        baseUrl: string;
-        apiKey?: string;
-        maxContextTokens?: number;
-        maxOutputTokens?: number;
-    }>;
-}): void;
-export declare function saveArenaSettingsByKeys(keys: string[]): void;

package/dist/cli/output/renderer.d.ts

@@ -1,28 +0,0 @@
-/**
- * Output renderers for different formats.
- */
-import type { StreamEvent, TerminalReason } from "../../types.js";
-export type OutputFormat = "text" | "json" | "jsonl" | "stream-json";
-export interface OutputRenderer {
-    onEvent(event: StreamEvent): void;
-    onComplete(text: string, reason: TerminalReason, meta: Record<string, unknown>): void;
-}
-export declare class TextRenderer implements OutputRenderer {
-    private activeAgents;
-    onEvent(event: StreamEvent): void;
-    onComplete(_text: string, reason: TerminalReason): void;
-}
-export declare class JsonRenderer implements OutputRenderer {
-    private text;
-    onEvent(event: StreamEvent): void;
-    onComplete(text: string, reason: TerminalReason, meta: Record<string, unknown>): void;
-}
-export declare class JsonlRenderer implements OutputRenderer {
-    onEvent(event: StreamEvent): void;
-    onComplete(text: string, reason: TerminalReason, meta: Record<string, unknown>): void;
-}
-export declare class StreamJsonRenderer implements OutputRenderer {
-    onEvent(event: StreamEvent): void;
-    onComplete(text: string, reason: TerminalReason, meta: Record<string, unknown>): void;
-}
-export declare function createRenderer(format: OutputFormat): OutputRenderer;

package/dist/cli/output/terminal-ui.d.ts

@@ -1,50 +0,0 @@
-/**
- * Terminal UI utilities — spinners, markdown rendering, styled output.
- */
-import { type Ora } from "ora";
-/**
- * Render markdown text to styled terminal output.
- * Falls back to raw text if rendering fails.
- */
-export declare function renderMarkdown(text: string): string;
-/**
- * Highlight a code block with syntax coloring.
- */
-export declare function highlightCode(code: string, lang?: string): string;
-export interface SpinnerHandle {
-    update(text: string): void;
-    succeed(text: string): void;
-    fail(text: string): void;
-    stop(): void;
-    instance: Ora;
-}
-/**
- * Create a spinner for long-running operations.
- */
-export declare function createSpinner(text: string): SpinnerHandle;
-/**
- * Print a styled banner box.
- */
-export declare function printBanner(lines: {
-    label: string;
-    value: string;
-}[]): void;
-/**
- * Format a tool call start line.
- */
-export declare function formatToolStart(toolName: string, args: Record<string, unknown>): string;
-/**
- * Format a tool result line.
- */
-export declare function formatToolResult(toolName: string, result?: string, error?: string): string;
-export interface TaskDisplayInfo {
-    id: string;
-    subject: string;
-    activeForm?: string;
-    status: "pending" | "in_progress" | "completed" | "stopped";
-}
-/**
- * Render the task list as a compact terminal block.
- * Returns the formatted string (caller handles printing).
- */
-export declare function renderTaskList(tasks: TaskDisplayInfo[]): string;

package/dist/cli/updater.d.ts

@@ -1,65 +0,0 @@
-/**
- * Auto-update — checks npm registry for newer versions; can optionally install
- * the new version in the background after the current process exits.
- *
- * Flow:
- *   1. `checkForUpdate()` runs at startup (non-blocking). Stores result in
- *      module state for the UI to read via `getUpdateAvailable()`.
- *   2. UI re-polls every 30 min via `pollForUpdate()`.
- *   3. If the user has write permission on the npm global prefix, we register
- *      `scheduleAutoInstallOnExit()` so that on process exit a detached
- *      `npm i -g` spawns and survives the parent. Next startup picks up
- *      the new version.
- *   4. If the user has NO permission, UI shows the manual command instead.
- *
- * Concurrency: multiple `code-shell` processes can run at once. A file lock
- * at `~/.code-shell/.update.lock` prevents both from launching `npm i -g`
- * simultaneously (which corrupts the install).
- *
- * Headless safety: `checkForUpdate()` and `scheduleAutoInstallOnExit()` are
- * only invoked from the Ink-based UpdateBanner component, never from the
- * `run` / `arena` headless code paths. Keep it that way — wiring the updater
- * into bare CLI commands would surprise CI users with background `npm i -g`
- * on every short-lived `code-shell run …` invocation. If you need updater
- * behavior in a new headless entry point, gate it on something explicit
- * (e.g. `--auto-update` flag) rather than calling it unconditionally.
- */
-export interface UpdateInfo {
-    latestVersion: string;
-    /** True if `<npm prefix>` is writable by current user — can self-install. */
-    canAutoInstall: boolean;
-    /** Cached npm global prefix path (for diagnostics / manual command hint). */
-    npmPrefix: string | null;
-}
-/**
- * Kick off an update check. Non-blocking: returns immediately, fills module
- * state when network/npm respond. Safe to call multiple times (e.g. on a 30min
- * timer).
- */
-export declare function checkForUpdate(packageName?: string): void;
-/** Returns update info if a newer version was found, else undefined. */
-export declare function getUpdateAvailable(): UpdateInfo | undefined;
-/** Returns "why is auto-update off" — for /doctor-style diagnostics. */
-export declare function getAutoUpdateDisabledReason(): string | null;
-/**
- * Install the on-exit hook so that the new version is installed AFTER the
- * current process exits (avoids overwriting files the running process still
- * has open). Idempotent — calling twice is a no-op.
- */
-export declare function scheduleAutoInstallOnExit(): void;
-export declare function getCurrentVersion(): string;
-declare function getLockFilePath(): string;
-/**
- * Try to acquire the update lock. Returns true on success.
- * Uses `O_EXCL` (writeFile flag 'wx') for atomic create. Stale locks (mtime
- * older than LOCK_TIMEOUT_MS) are taken over, re-verifying staleness right
- * before unlink to close the TOCTOU race.
- */
-declare function acquireLock(): Promise<boolean>;
-declare function releaseLock(): Promise<void>;
-export declare const __internal: {
-    acquireLock: typeof acquireLock;
-    releaseLock: typeof releaseLock;
-    getLockFilePath: typeof getLockFilePath;
-};
-export {};

package/dist/client-base-GSFXPP2Y.js

@@ -1 +0,0 @@
-export{a as LLMClientBase}from'./chunk-OWBYLMDD.js';import'./chunk-FU7AHZNN.js';import'./chunk-DI26OUIU.js';import'./chunk-3QP5BQ3L.js';

package/dist/compaction-L3Y6NG4N.js

@@ -1 +0,0 @@
-import {p}from'./chunk-M7VU4YVY.js';export{e as COMPACTABLE_TOOL_NAMES,b as adjustIndexToPreserveAPIInvariants,k as applySummaryCompaction,g as applyToolResultBudget,i as buildSummarizationPrompt,m as dropOldestRounds,a as estimateTokens,j as extractAnchoredSummary,n as extractReferencedFilePaths,l as groupMessagesByApiRound,f as microcompact,c as snipCompact,h as truncateToolResult,d as windowCompact}from'./chunk-M7VU4YVY.js';import'./chunk-3QP5BQ3L.js';p();

package/dist/context/compaction.d.ts

@@ -1,116 +0,0 @@
-/**
- * Context compaction strategies.
- *
- * Tier 0: truncateToolResult — truncate oversized individual results
- * Tier 1: microcompact — zero-cost, clears old tool_result content
- * Tier 2: LLM summary — generates summary via model call (async)
- * Tier 3: window compact — keeps first + last N messages (sync fallback)
- * Emergency: dropOldestRounds — progressive API-round-based truncation
- *
- * All slicing functions use adjustIndexToPreserveAPIInvariants()
- * to prevent splitting tool_use / tool_result pairs.
- */
-import type { Message } from "../types.js";
-/**
- * Estimate token count from messages.
- * Uses per-block-type estimation with 33% overhead padding.
- */
-export declare function estimateTokens(messages: Message[]): number;
-/**
- * Expand a slice start-index backwards so that every tool_result in the
- * kept range has its corresponding tool_use in the kept range too.
- *
- * Without this, windowCompact / applySummaryCompaction can produce
- * messages where tool_result references a tool_use_id that was
- * compacted away, causing an API validation error.
- */
-export declare function adjustIndexToPreserveAPIInvariants(messages: Message[], startIndex: number): number;
-/**
- * Snip strategy: keep first N + last M messages, replace middle with a marker.
- * Less aggressive than windowCompact — preserves initial context AND recent history.
- * Uses adjustIndexToPreserveAPIInvariants on both boundaries.
- */
-export declare function snipCompact(messages: Message[], keepFirstN?: number, keepLastM?: number): Message[];
-/**
- * Window strategy: keep first message + last N messages.
- * Uses adjustIndexToPreserveAPIInvariants to avoid splitting tool pairs.
- */
-export declare function windowCompact(messages: Message[], keepLastN: number): Message[];
-/**
- * Tools whose results are safe to clear during microcompact.
- *
- * Tracks the CC `COMPACTABLE_TOOLS` set: only "data-fetching" tools where the
- * result is reconstructible (re-Read, re-Glob, re-Bash). Orchestration tools
- * (TaskCreate / TaskUpdate / Agent / Skill / etc.) are excluded — their
- * results carry conversation state the model needs to keep referencing.
- */
-export declare const COMPACTABLE_TOOL_NAMES: ReadonlySet<string>;
-export interface MicrocompactOptions {
-    /** Keep this many most-recent compactable tool-result rounds untouched. */
-    keepRecentN?: number;
-    /** Tool names whose results may be cleared. Defaults to COMPACTABLE_TOOL_NAMES. */
-    compactableTools?: ReadonlySet<string>;
-    /** Optional callback invoked once when any clearing actually happened. */
-    onClear?: (info: {
-        clearedRounds: number;
-        toolNames: string[];
-    }) => void;
-}
-/**
- * Remove old tool_result content (microcompact).
- *
- * For each tool_result block older than the most-recent N compactable rounds,
- * replaces its content with a short fingerprint of the originating call
- * (e.g. `[Old tool result cleared — Read file_path=/.../foo.ts]`) so the
- * model can decide whether it's worth re-running the tool instead of
- * guessing what it had seen.
- *
- * Behavior changes vs. earlier versions:
- *  - Only clears whitelisted tool names (Read/Glob/Bash/...). Orchestration
- *    tool results (TaskCreate/TaskUpdate/Agent/etc.) are left intact.
- *  - "Round" count is per *compactable* result, not per message with any
- *    tool_result. A round containing only TaskUpdate doesn't count toward N.
- *  - Replacement string includes tool name + key args so the model isn't
- *    forced into blind re-Reads (which then trip the Investigation guard).
- */
-export declare function microcompact(messages: Message[], options?: MicrocompactOptions): Message[];
-/**
- * Apply aggregate per-message tool result budget.
- * When total tool_result content in a single message exceeds maxTotalChars,
- * truncates the largest results first with a notice.
- */
-export declare function applyToolResultBudget(messages: Message[], maxTotalChars?: number): Message[];
-/**
- * Truncate a single tool result if it exceeds the character limit.
- * Returns the truncated string with a notice.
- */
-export declare function truncateToolResult(result: string, maxChars?: number): string;
-/**
- * Build a structured summarization prompt from messages to be compacted.
- * Produces a 9-section summary preserving key details.
- */
-export declare function buildSummarizationPrompt(messagesToSummarize: Message[], priorSummary?: string): string;
-export declare function extractAnchoredSummary(messages: Message[]): string | undefined;
-/**
- * Apply LLM-generated summary compaction (hybrid mode).
- *
- * Instead of eagerly restoring file contents (wastes tokens), gives the
- * model a summary + the transcript path so it can Read on demand.
- * Also lists recently-referenced files so the model knows what to re-read.
- */
-export declare function applySummaryCompaction(messages: Message[], summary: string, keepRecentN: number, transcriptPath?: string): Message[];
-/**
- * Group messages by API round-trip boundaries.
- * Each group represents one complete assistant response + its tool results.
- */
-export declare function groupMessagesByApiRound(messages: Message[]): Message[][];
-/**
- * Drop the oldest API rounds from messages, preserving tool pairs.
- * Used for progressive prompt-too-long recovery.
- */
-export declare function dropOldestRounds(messages: Message[], roundsToDrop: number): Message[];
-/**
- * Extract file paths that were referenced (Read/Edit/Write) in compacted
- * messages. Returns paths only — the model uses Read tool on demand.
- */
-export declare function extractReferencedFilePaths(messages: Message[]): string[];

package/dist/context/manager.d.ts

@@ -1,145 +0,0 @@
-/**
- * Context manager — three-tier context management.
- *
- * Tier 1: microcompact (sync, zero-cost) — clear old tool_result content
- * Tier 2: LLM summary (async) — generate summary of older messages via model call
- * Tier 3: window compact (sync, emergency) — aggressive truncation fallback
- */
-import type { Message } from "../types.js";
-export interface ContextManagerConfig {
-    maxTokens: number;
-    compactAtRatio: number;
-    summarizeAtRatio: number;
-    maxToolResultChars: number;
-    /**
-     * Lower bound, as a ratio of maxTokens, below which microcompact will not
-     * run. CC's external (non-cache-edit) path is "autocompact handles context
-     * pressure"; mirror that by leaving early-turn context alone so a model
-     * with a 1M window doesn't see its first-3-rounds Read results wiped at
-     * 23k tokens. Raising the floor also keeps prompt-cache prefixes warm in
-     * short sessions.
-     */
-    microcompactFloorRatio: number;
-    /**
-     * Most-recent compactable rounds microcompact keeps untouched. Auto-derived
-     * from maxTokens when not set explicitly: bigger window → keep more.
-     */
-    microcompactKeepRecent?: number;
-}
-/**
- * Async function type for LLM summarization calls.
- * Injected by the Engine so the ContextManager doesn't depend on LLM directly.
- */
-export type SummarizeFn = (prompt: string) => Promise<string>;
-export type CompactStrategy = "micro" | "summary" | "window" | "snip" | "emergency";
-export type OnCompactFn = (info: {
-    strategy: CompactStrategy;
-    before: number;
-    after: number;
-}) => void;
-export declare class ContextManager {
-    private config;
-    private toolCallHashes;
-    private summarizeFn;
-    private consecutiveSummaryFailures;
-    private lastSummary;
-    /** Last known actual token count from API usage data. */
-    private lastActualTokens;
-    /** Message count at the time lastActualTokens was recorded. */
-    private lastActualAtMessageCount;
-    /** Path to session transcript — passed to summary compaction for on-demand access. */
-    private transcriptPath;
-    /** Notified whenever any compaction tier fires, including microcompact. */
-    private onCompact;
-    /**
-     * Tool-result persistence state. Created lazily once we know where to
-     * write files (i.e. once setTranscriptPath has been called).
-     * `null` = persistence has been explicitly disabled.
-     */
-    private replacementState;
-    private toolResultsDir;
-    constructor(config?: Partial<ContextManagerConfig>);
-    setOnCompact(fn: OnCompactFn): void;
-    /**
-     * Record actual token usage from API response.
-     * Used for hybrid estimation: actual + estimate for new messages.
-     */
-    recordActualUsage(inputTokens: number, messageCount: number): void;
-    /**
-     * Best-effort token estimate: uses actual API usage as base if available,
-     * plus estimation for messages added since the last API call.
-     */
-    private estimateTokensHybrid;
-    /**
-     * Set the summarize function (injected by Engine).
-     */
-    setSummarizeFn(fn: SummarizeFn): void;
-    /**
-     * Set the transcript path so compaction can reference it. The
-     * tool-results directory lives alongside the transcript file:
-     *   <transcriptDir>/tool-results/<toolUseId>.txt
-     */
-    setTranscriptPath(path: string): void;
-    /**
-     * Initialize tool-result-persistence state from already-loaded messages.
-     * Call this once per session, after setTranscriptPath, when resuming so
-     * the manager re-enters the same "frozen decision" state it had on the
-     * previous run. Without this, a resumed session would re-evaluate
-     * every result against the current threshold and might flip choices.
-     */
-    initReplacementStateFromMessages(messages: Message[]): void;
-    /**
-     * Apply progressive context management (sync path).
-     * For Tier 2 (LLM summary), call manageAsync instead.
-     */
-    manage(messages: Message[]): Message[];
-    /**
-     * Async context management — attempts LLM summarization before falling back.
-     * Call this when you have access to the LLM (between turns).
-     */
-    manageAsync(messages: Message[]): Promise<Message[]>;
-    /**
-     * Persist large tool_result blocks to disk and replace them with a
-     * preview + filepath. No-op when transcript path hasn't been set
-     * (e.g. unit tests that exercise compaction directly without a session).
-     */
-    private persistLargeToolResults;
-    /**
-     * Truncate oversized tool results in messages.
-     */
-    private truncateToolResults;
-    /**
-     * Reactive compaction check — call during streaming to detect if
-     * token usage is approaching the limit mid-turn.
-     * Returns true if emergency compaction should be triggered.
-     */
-    shouldReactiveCompact(messages: Message[], currentResponseTokens: number): boolean;
-    /**
-     * Check if context is approaching limits.
-     */
-    checkLimits(messages: Message[]): {
-        tokens: number;
-        ratio: number;
-        needsCompact: boolean;
-        needsEmergency: boolean;
-    };
-    /**
-     * Deduplicate tool calls by hashing arguments.
-     */
-    deduplicateToolCalls(calls: Array<{
-        toolName: string;
-        args: Record<string, unknown>;
-    }>): {
-        toExecute: typeof calls;
-        cached: Array<{
-            toolName: string;
-            args: Record<string, unknown>;
-            result: string;
-        }>;
-    };
-    /**
-     * Record a tool call result for dedup tracking.
-     */
-    recordToolResult(toolName: string, args: Record<string, unknown>, result: string): void;
-    private hashCall;
-}

package/dist/context/token-counter.d.ts

@@ -1,27 +0,0 @@
-/**
- * Token counter — more accurate token estimation.
- *
- * Uses a character-based heuristic tuned per language/content type,
- * with cache-aware accounting for prompt caching.
- */
-import type { Message } from "../types.js";
-/**
- * Estimate token count for a string, detecting content type.
- */
-export declare function estimateStringTokens(text: string): number;
-/**
- * Estimate token count for a message array.
- */
-export declare function estimateMessagesTokens(messages: Message[]): number;
-/**
- * Context window usage report.
- */
-export interface ContextUsage {
-    usedTokens: number;
-    maxTokens: number;
-    usagePercent: number;
-    systemPromptTokens: number;
-    messagesTokens: number;
-    headroom: number;
-}
-export declare function calculateContextUsage(messages: Message[], systemPrompt: string, maxTokens: number): ContextUsage;