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

package/dist/context/tool-result-storage.d.ts

@@ -1,96 +0,0 @@
-/**
- * Tool-result persistence — write large tool_result content to disk and
- * replace the in-context message with a reference + preview.
- *
- * Mirrors Claude Code's services/compact/microcompact.ts + utils/toolResultStorage.ts
- * approach, simplified for codeshell:
- *
- *   • One file per tool_use_id (UUID), so the same id always maps to the
- *     same file — guarantees byte-identical preview on every turn.
- *   • Decision state (ContentReplacementState) is held by the caller and
- *     mutated in place. Once a result is "seen", its fate is frozen for
- *     the rest of the session (prevents flapping replacement choices that
- *     would constantly invalidate the prompt prefix).
- *   • No transcript persistence / no fork-subagent gap-fill. Resume just
- *     re-derives the seenIds set from the loaded messages.
- *
- * Strategy:
- *   • Per-result cap (DEFAULT_PERSIST_THRESHOLD): when a single tool_result
- *     exceeds it, persist + replace.
- *   • Per-message aggregate cap (PER_MESSAGE_AGGREGATE_CAP): when a single
- *     user message's tool_results together exceed it (e.g. a batch of
- *     parallel Read results), persist the largest ones first until under.
- */
-import type { Message } from "../types.js";
-/** Per-result threshold. Larger than this → persist + replace. */
-export declare const DEFAULT_PERSIST_THRESHOLD = 50000;
-/** Per-message aggregate cap (sum of tool_result content sizes in one user msg). */
-export declare const PER_MESSAGE_AGGREGATE_CAP = 200000;
-/** Preview length included in the replacement string. */
-export declare const PREVIEW_SIZE = 2000;
-/**
- * Per-session decision state for tool-result persistence.
- *
- *  seenIds       — every tool_use_id we've evaluated; once seen, its fate
- *                  (persisted or not) is fixed for the rest of the session.
- *  replacements  — subset of seenIds that were persisted, mapped to the
- *                  EXACT replacement string sent to the model. Re-applying
- *                  is a Map lookup, never re-reads the file, guarantees
- *                  byte-identical output.
- */
-export interface ContentReplacementState {
-    seenIds: Set<string>;
-    replacements: Map<string, string>;
-}
-export declare function createContentReplacementState(): ContentReplacementState;
-/**
- * Rebuild a state object by walking the loaded message history.
- * Used on resume so the budget makes the same decisions it made before.
- * Replacements are taken from the messages themselves (we identify them
- * by the PERSISTED_OPEN sentinel), so we don't need a side-channel log.
- */
-export declare function reconstructContentReplacementState(messages: Message[]): ContentReplacementState;
-/**
- * Resolve the directory tool results are written to, given the engine's
- * transcript path. Layout:  <transcriptDir>/tool-results/
- */
-export declare function resolveToolResultsDir(transcriptPath: string): string;
-interface PersistOptions {
-    /** Per-result threshold; default DEFAULT_PERSIST_THRESHOLD. */
-    perResultThreshold?: number;
-    /** Per-message aggregate cap; default PER_MESSAGE_AGGREGATE_CAP. */
-    perMessageCap?: number;
-    /** Directory to write tool-result files to. Required. */
-    toolResultsDir: string;
-    /** Decision state, mutated in place. */
-    state: ContentReplacementState;
-    /** Optional callback fired when a result is freshly persisted. */
-    onPersist?: (info: {
-        toolUseId: string;
-        filepath: string;
-        originalSize: number;
-        reason: "per-result-cap" | "per-message-budget";
-    }) => void;
-}
-/**
- * Walk each user message, decide which tool_result blocks should be
- * persisted (per-result cap OR per-message aggregate), persist them,
- * and return a new message array with those blocks replaced.
- *
- * Frozen decisions:
- *  - If a tool_use_id is already in state.replacements, that exact
- *    replacement is re-applied (no I/O).
- *  - If it's in state.seenIds but NOT replacements, it was decided
- *    "don't persist" on an earlier pass — leave it unreplaced even if
- *    it now exceeds the threshold (changing the decision mid-session
- *    would invalidate any model state built on the prior content).
- *
- * @returns the new messages array, with replacements applied.
- */
-export declare function applyToolResultPersistence(messages: Message[], options: PersistOptions): Message[];
-/**
- * Public test helper: check whether content already wears the persisted
- * sentinel. Used by tests to assert idempotency.
- */
-export declare function isPersistedReplacement(s: string): boolean;
-export {};

package/dist/cron/scheduler.d.ts

@@ -1,34 +0,0 @@
-/**
- * Cron scheduler — schedule and manage recurring agent tasks.
- *
- * Supports simple cron-like intervals. Each job runs the Engine
- * with a predefined prompt on schedule.
- */
-export interface CronJob {
-    id: string;
-    name: string;
-    schedule: string;
-    prompt: string;
-    enabled: boolean;
-    lastRun?: number;
-    nextRun?: number;
-    runCount: number;
-    createdAt: number;
-}
-declare class CronScheduler {
-    private jobs;
-    private timers;
-    private nextId;
-    private onExecute?;
-    setExecutor(fn: (job: CronJob) => Promise<void>): void;
-    create(name: string, schedule: string, prompt: string): CronJob;
-    delete(id: string): boolean;
-    list(): CronJob[];
-    get(id: string): CronJob | undefined;
-    pause(id: string): boolean;
-    resume(id: string): boolean;
-    stopAll(): void;
-    private startTimer;
-}
-export declare const cronScheduler: CronScheduler;
-export {};

package/dist/data/openrouter-models.d.ts

@@ -1,35 +0,0 @@
-/**
- * Runtime accessor for the OpenRouter model snapshot.
- *
- * The snapshot is generated at build time by `scripts/sync-models.ts`
- * from https://openrouter.ai/api/v1/models. Reading happens lazily on
- * first call, so the JSON is parsed at most once per process.
- *
- * If the snapshot is missing or empty (e.g. first checkout before a
- * build, or sync failure with no prior file), accessors return [] and
- * callers should fall back to hardcoded defaults.
- */
-export interface OpenRouterModel {
-    id: string;
-    name: string;
-    created: number;
-    contextLength: number;
-    maxOutputTokens: number;
-    inputPricePerMillion: number;
-    outputPricePerMillion: number;
-    modalities: string[];
-}
-interface Snapshot {
-    fetchedAt: string;
-    source: string;
-    count: number;
-    models: OpenRouterModel[];
-}
-/** Replace the in-memory snapshot for the rest of this process. */
-export declare function setOpenRouterSnapshot(next: Snapshot): void;
-export declare function getOpenRouterSnapshot(): Snapshot;
-export declare function getOpenRouterModels(): OpenRouterModel[];
-export declare function findOpenRouterModel(id: string): OpenRouterModel | undefined;
-/** Models filtered by vendor prefix, e.g. "anthropic", "openai", "deepseek". */
-export declare function listOpenRouterModelsByVendor(vendor: string): OpenRouterModel[];
-export {};

package/dist/data/openrouter-sync.d.ts

@@ -1,16 +0,0 @@
-/**
- * Runtime sync of the OpenRouter model catalog.
- *
- * Fetches openrouter.ai/api/v1/models and replaces the bundled snapshot
- * in memory for the rest of the process. Used by the /sync-models slash
- * command. To persist a sync across restarts, re-run the build (which
- * re-runs scripts/sync-models.ts).
- */
-import { getOpenRouterSnapshot } from "./openrouter-models.js";
-export interface SyncResult {
-    ok: boolean;
-    count: number;
-    error?: string;
-}
-export declare function syncOpenRouterCatalog(timeoutMs?: number): Promise<SyncResult>;
-export { getOpenRouterSnapshot };

package/dist/data/static-catalogs.d.ts

@@ -1,25 +0,0 @@
-/**
- * Hand-maintained static model catalogs for providers whose /v1/models
- * endpoint returns only ids — no context window, max output, or pricing.
- *
- * At runtime we still call the live /models endpoint to discover ids
- * (so newly-released models work without a code update), then left-join
- * this table on `id` to fill in metadata. Edit the JSONs in src/data/
- * when a vendor ships a new model.
- *
- * OpenRouter is NOT here — its catalog is generated at build time by
- * scripts/sync-models.ts because OpenRouter exposes full metadata.
- */
-import type { ProviderKindName } from "../llm/provider-kinds.js";
-export interface StaticModel {
-    id: string;
-    name: string;
-    contextLength: number;
-    maxOutputTokens: number;
-    inputPricePerMillion: number;
-    outputPricePerMillion: number;
-    modalities: string[];
-    thinking?: boolean;
-}
-export declare function listStaticModels(kind: ProviderKindName): StaticModel[];
-export declare function hasStaticCatalog(kind: ProviderKindName): boolean;

package/dist/devtools-FBX4HVVY.js

@@ -1 +0,0 @@
-export{a as recordFrame,b as renderDevtools}from'./chunk-GYNO4R7R.js';import'./chunk-3QP5BQ3L.js';

package/dist/engine/cost-store.d.ts

@@ -1,22 +0,0 @@
-/**
- * CostStateStore — an opaque snapshot/restore hook that Engine uses to
- * persist session-level cost state across `run({ sessionId })` calls.
- *
- * Engine itself doesn't compute prices or format summaries; it just hands
- * the state blob to whatever store was injected. The CLI's `costTracker`
- * is one concrete implementation; a SaaS backend might implement this
- * against a database instead.
- *
- * Default: no store is injected, and cost state is not persisted. Engine
- * continues to report per-run token usage via `EngineResult.usage` and
- * `LLMClientBase.getUsage()` — this hook is only for the
- * "resume-and-keep-counting" scenario.
- */
-/** Arbitrary serializable snapshot — opaque to Engine. */
-export type CostStateSnapshot = unknown;
-export interface CostStateStore {
-    /** Serialize current cost state for persistence. */
-    serialize(): CostStateSnapshot;
-    /** Restore previously-serialized cost state. */
-    restore(state: CostStateSnapshot): void;
-}

package/dist/engine/engine.d.ts

@@ -1,236 +0,0 @@
-/**
- * Engine — the main facade that wires all components together.
- */
-import type { LLMConfig, StreamCallback, TerminalReason, TokenUsage } from "../types.js";
-import { ToolRegistry } from "../tool-system/registry.js";
-import { type ApprovalBackend } from "../tool-system/permission.js";
-import { HookRegistry } from "../hooks/registry.js";
-import type { HookEventName } from "../hooks/events.js";
-import type { HookHandler } from "../hooks/registry.js";
-import { SessionManager } from "../session/session-manager.js";
-import type { CostStateStore } from "./cost-store.js";
-import type { AskUserFn } from "../tool-system/builtin/ask-user.js";
-import { type SandboxConfig } from "../tool-system/sandbox/index.js";
-import { type AgentPresetName } from "../preset/index.js";
-import { ModelPool, type ModelEntry } from "../llm/model-pool.js";
-export interface EngineConfig {
-    llm: LLMConfig;
-    cwd?: string;
-    maxTurns?: number;
-    maxToolCallsPerTurn?: number;
-    permissionMode?: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan";
-    preset?: AgentPresetName;
-    enabledBuiltinTools?: string[];
-    disabledBuiltinTools?: string[];
-    customSystemPrompt?: string;
-    appendSystemPrompt?: string;
-    sessionStorageDir?: string;
-    maxContextTokens?: number;
-    approvalBackend?: ApprovalBackend;
-    hooks?: EngineHookConfig[];
-    askUser?: AskUserFn;
-    mcpServers?: Record<string, import("../types.js").MCPServerConfig>;
-    /**
-     * Optional opaque store for per-session cost/usage state. When provided,
-     * Engine calls `restore()` on session resume and `serialize()` at the end
-     * of each `run()` and stores the blob on the session. Without this the
-     * Engine doesn't persist cost state — it's a UI concern.
-     */
-    costStore?: CostStateStore;
-    /**
-     * True when the Engine runs in a no-UI / one-shot context (e.g. the `run`
-     * command). Currently controls InvestigationGuard soft-mode: in headless
-     * we never hard-block a tool call because there is no human to retry.
-     * Defaults to false.
-     */
-    headless?: boolean;
-    /**
-     * Sandbox configuration for shell-tool execution. When omitted, headless
-     * runs default to "auto" (Seatbelt on macOS / bwrap on Linux when
-     * available) and interactive runs default to "off" because a human is in
-     * the loop to approve commands.
-     */
-    sandbox?: SandboxConfig;
-    /**
-     * True when this Engine is itself a sub-agent (spawned by another
-     * Engine's Agent tool). Threaded into ToolContext so the Agent tool can
-     * refuse re-entry — defense in depth against the tool-list strip in
-     * spawn(): if a tool registry regression ever leaks Agent into a child's
-     * pool, the runtime check still blocks the call.
-     */
-    isSubAgent?: boolean;
-}
-export interface EngineHookConfig {
-    event: HookEventName;
-    handler: HookHandler;
-    priority?: number;
-    name?: string;
-}
-export interface EngineResult {
-    text: string;
-    reason: TerminalReason;
-    sessionId: string;
-    turnCount: number;
-    usage: TokenUsage;
-}
-export declare class Engine {
-    private config;
-    private readonly preset;
-    private toolRegistry;
-    private hooks;
-    private sessionManager;
-    private mcpManager;
-    private modelPool;
-    private settingsManager;
-    private lastContextManager;
-    private lastMessages;
-    private lastSessionId;
-    private compactedMessagesBySession;
-    /**
-     * SIDs whose ctx-bar seed we've already emitted in this process. The seed
-     * is a rough char/4 estimate; only useful before the first real
-     * usage_update arrives (cold start or cross-process resume). On subsequent
-     * turns the UI already shows the previous turn's accurate ctx — re-seeding
-     * would visibly drop the bar on every submit.
-     */
-    private ctxSeedSent;
-    /**
-     * Per-sid cache of "non-messages overhead" (system prompt + tool defs, in
-     * tokens). Survives across turns so each fresh TurnLoop instance can seed
-     * its first pre-llm emit with the right offset — without this the ctx bar
-     * visibly drops on every user submit (e.g. from ~20k → 3k) until the next
-     * LLM response arrives.
-     */
-    private ctxOverheadBySid;
-    private activePermission;
-    /** Public accessor so UI/clients can read the resolved per-model window. */
-    get maxContextTokens(): number;
-    private resolveMaxContextTokens;
-    /**
-     * Emit a lifecycle hook with isSubAgent auto-merged into data so handlers
-     * can skip noisy injections for spawned children. All Engine-side hook
-     * emits should go through this wrapper to keep the context envelope
-     * uniform with TurnLoop.emitHook.
-     */
-    private emitHook;
-    /**
-     * Read settings.hooks and register a shell-runner wrapper handler per
-     * entry. Sub-agents skip shell hooks entirely — spawning child processes
-     * per emit for every sub-agent run would multiply token-side overhead
-     * for marginal value; explicit users who want sub-agent observability
-     * should register SDK-side handlers.
-     */
-    private registerSettingsHooks;
-    constructor(config: EngineConfig);
-    /**
-     * Load models[] / providers[] from settings into the active ModelPool and
-     * resync this.config.llm with the matching entry. Called from the ctor and
-     * from reloadModelPool() (e.g. after onboarding writes new entries to disk).
-     */
-    private populateModelPoolFromSettings;
-    /**
-     * Re-read settings and refresh the model pool. Used after onboarding /login
-     * writes new providers[] / models[] to disk so the running engine picks them
-     * up without a process restart. Existing pool entries are kept (re-registering
-     * the same key overwrites them), so callers don't need to clear first.
-     */
-    reloadModelPool(): void;
-    /**
-     * Auto-populate the model pool when settings.models[] is empty but
-     * the user has configured an API key. Detects the provider from the
-     * key prefix / baseUrl and registers all its known models.
-     */
-    private autoPopulatePool;
-    /**
-     * Register a custom tool (from product adapter) into the tool registry.
-     * Must be called before run().
-     */
-    registerCustomTool(definition: import("../types.js").RegisteredTool, executor: (args: Record<string, unknown>) => Promise<string>): void;
-    /**
-     * Inject the askUser handler after construction. Used by AgentServer
-     * to wire its protocol-backed askUser into an Engine that was created
-     * before the server existed (chicken-and-egg: server takes engine in ctor).
-     */
-    setAskUser(fn: AskUserFn | undefined): void;
-    /**
-     * Run a task from start to finish.
-     */
-    run(task: string, options?: {
-        onStream?: StreamCallback;
-        signal?: AbortSignal;
-        sessionId?: string;
-    }): Promise<EngineResult>;
-    /**
-     * Run the end-of-session memory pipeline as a fire-and-forget background
-     * task. Extracts durable memories from the transcript, saves a session
-     * summary, and conditionally triggers auto-dream consolidation.
-     */
-    private runMemoryPipeline;
-    getToolRegistry(): ToolRegistry;
-    /**
-     * Switch the active model by pool key. Takes effect on the next run() call.
-     * Returns the new model entry.
-     *
-     * Persists settings.activeKey (and a legacy settings.model.* mirror) so the
-     * next process startup defaults to the same model — without this, switches
-     * only live in memory and every restart reverts to the previously persisted
-     * activeKey.
-     */
-    switchModel(key: string): ModelEntry;
-    /**
-     * Write the active model selection to ~/.code-shell/settings.json.
-     *
-     * We mirror into the legacy settings.model.* block (provider/name/apiKey/
-     * baseUrl) because boot paths in cli/main.ts, repl.ts, run.ts still read it.
-     * The mirror uses resolved llm values (not raw entry.*) so credentials that
-     * live on settings.providers[] flow through correctly — entry.apiKey is
-     * undefined when the entry resolves via providerCatalog.
-     */
-    private persistActiveModel;
-    /** Get the model pool. */
-    getModelPool(): ModelPool;
-    /** Get the current model name (full path). */
-    getCurrentModel(): string;
-    getHookRegistry(): HookRegistry;
-    getSessionManager(): SessionManager;
-    getConfig(): EngineConfig;
-    /**
-     * Inject context into a session's transcript without triggering a LLM turn.
-     * The injected content appears as an assistant message so the LLM can see it
-     * in subsequent conversations. The transcript auto-flushes to disk.
-     *
-     * Also updates the in-memory compacted message cache so the next
-     * engine.run() call for this session picks up the injected content
-     * instead of a stale snapshot from the previous run.
-     */
-    injectContext(sessionId: string, content: string): void;
-    /**
-     * Force context compaction on the current session.
-     * Returns token stats before/after.
-     */
-    forceCompact(): {
-        before: number;
-        after: number;
-        strategy: string;
-    };
-    private stripUserContextMessage;
-    private getSettingsManager;
-    /**
-     * Update a config setting at runtime.
-     */
-    updateConfig(key: string, value: unknown): void;
-    /**
-     * Read a settings value by dotted key (e.g. "arena.participants").
-     * Returns undefined if any segment is missing.
-     */
-    readSetting(key: string): unknown;
-    private buildPermissionConfig;
-    /**
-     * Switch permission mode at runtime. Takes effect immediately for any
-     * in-flight ToolExecutor (which holds a reference to the same classifier),
-     * and the new mode is used for any subsequent run() calls.
-     * Session-only — does not persist to settings.
-     */
-    setPermissionMode(mode: NonNullable<EngineConfig["permissionMode"]>): void;
-    getPermissionMode(): NonNullable<EngineConfig["permissionMode"]>;
-}

package/dist/engine/model-facade.d.ts

@@ -1,24 +0,0 @@
-/**
- * Model call facade — wraps LLM client with transcript integration.
- */
-import type { LLMClientBase } from "../llm/client-base.js";
-import type { Message, ToolDefinition, LLMResponse, StreamCallback } from "../types.js";
-import { Transcript } from "../session/transcript.js";
-export declare class ModelFacade {
-    private readonly client;
-    private readonly transcript;
-    constructor(client: LLMClientBase, transcript: Transcript);
-    call(systemPrompt: string, messages: Message[], tools: ToolDefinition[], onStream?: StreamCallback, signal?: AbortSignal): Promise<LLMResponse>;
-    /**
-     * Call without streaming — used as fallback when streaming fails.
-     */
-    callWithoutStreaming(systemPrompt: string, messages: Message[], tools: ToolDefinition[], signal?: AbortSignal): Promise<LLMResponse>;
-    /** Record API timing and token usage to bootstrap state. */
-    private recordUsage;
-    /** Optional summarize function for tool use summaries. */
-    summarize?: (systemPrompt: string, userMessage: string) => Promise<string>;
-    /** Get cumulative output tokens (for token budget). */
-    getOutputTokens?(): number;
-    private recordResponse;
-    getUsage(): import("../llm/types.js").LLMUsageTracker;
-}

package/dist/engine/query.d.ts

@@ -1,50 +0,0 @@
-/**
- * High-level query API — async generator wrapping TurnLoop.
- *
- * Callers consume events via `for await (const event of query(params))`.
- * This is the public entry point for running agentic queries; TurnLoop
- * is the internal state machine.
- *
- * Adapted from restored-src/src/query.ts, simplified for Code Shell.
- */
-import type { Message, StreamEvent, ToolDefinition, TerminalReason } from "../types.js";
-import { type TurnLoopDeps } from "./turn-loop.js";
-export interface QueryParams {
-    /** Initial message history (including the new user message). */
-    messages: Message[];
-    /** System prompt text. */
-    systemPrompt: string;
-    /** Available tool definitions. */
-    tools: ToolDefinition[];
-    /** Max turns before forced stop. */
-    maxTurns?: number;
-    /** Max tool calls per turn (default 20). */
-    maxToolCallsPerTurn?: number;
-    /** Abort signal for cancellation. */
-    signal?: AbortSignal;
-    /** Dependencies injected by the caller (engine). */
-    deps: QueryDeps;
-}
-export interface QueryDeps {
-    model: TurnLoopDeps["model"];
-    toolExecutor: TurnLoopDeps["toolExecutor"];
-    contextManager: TurnLoopDeps["contextManager"];
-    hooks: TurnLoopDeps["hooks"];
-    transcript: TurnLoopDeps["transcript"];
-}
-export interface QueryResult {
-    text: string;
-    reason: TerminalReason;
-    turnCount: number;
-}
-/**
- * Run an agentic query and yield stream events as they occur.
- *
- * Usage:
- *   const events: StreamEvent[] = [];
- *   for await (const event of query(params)) {
- *     events.push(event);
- *   }
- *   // last event contains the final result
- */
-export declare function query(params: QueryParams): AsyncGenerator<StreamEvent, QueryResult, undefined>;

package/dist/engine/streaming-tool-queue.d.ts

@@ -1,34 +0,0 @@
-/**
- * Streaming tool queue — enqueues tools for execution during streaming,
- * starts concurrency-safe tools immediately, queues unsafe tools for
- * sequential execution.
- *
- * Usage:
- *   const queue = new StreamingToolQueue(executor);
- *   // During streaming, as tool_use blocks arrive:
- *   queue.enqueue(toolCall);
- *   // After streaming completes:
- *   const results = await queue.drain();
- */
-import type { ToolCall, ToolResult } from "../types.js";
-import type { ToolExecutor } from "../tool-system/executor.js";
-export declare class StreamingToolQueue {
-    private readonly executor;
-    private readonly pending;
-    private readonly unsafeQueue;
-    private readonly callOrder;
-    private draining;
-    constructor(executor: ToolExecutor);
-    /**
-     * Enqueue a tool for execution. Concurrency-safe tools start immediately;
-     * unsafe tools are queued for sequential execution during drain().
-     */
-    enqueue(call: ToolCall): void;
-    /**
-     * Execute all remaining unsafe tools sequentially, then await all results.
-     * Returns results in original enqueue order.
-     */
-    drain(): Promise<ToolResult[]>;
-    /** Number of tools currently enqueued or executing. */
-    get size(): number;
-}

package/dist/engine/token-budget.d.ts

@@ -1,22 +0,0 @@
-/**
- * Token budget — decides whether the agent loop should continue, nudge, or stop.
- *
- * - "continue": keep going normally
- * - "nudge": inject a "please wrap up" message, but continue
- * - "stop": terminate the loop gracefully
- */
-export interface BudgetTracker {
-    continuationCount: number;
-    lastDeltaTokens: number;
-    prevTurnTokens: number;
-}
-export declare function createBudgetTracker(): BudgetTracker;
-export type BudgetDecision = "continue" | "nudge" | "stop";
-/**
- * Check if the turn loop should continue based on token output budget.
- *
- * @param turnOutputTokens - tokens output so far this turn
- * @param budget - max tokens allowed for this turn (Infinity = no limit)
- * @param tracker - mutable tracker state (updated in place)
- */
-export declare function checkTokenBudget(turnOutputTokens: number, budget: number, tracker: BudgetTracker): BudgetDecision;

package/dist/engine/tool-summary.d.ts

@@ -1,13 +0,0 @@
-/**
- * Tool use summary — generates a 1-line progress label after tool batch execution.
- *
- * Runs async (fire-and-forget) so it doesn't block the next model call.
- * Returns a short commit-subject-style string like "Read 3 files, fixed NPE in auth.ts"
- */
-import type { ToolCall, ToolResult } from "../types.js";
-export type SummarizeFn = (systemPrompt: string, userMessage: string) => Promise<string>;
-/**
- * Generate a 1-line summary of completed tool executions.
- * Returns null on failure (non-critical).
- */
-export declare function generateToolUseSummary(toolCalls: ToolCall[], results: ToolResult[], summarize: SummarizeFn): Promise<string | null>;