agent-sh 0.9.0 → 0.10.1

package/dist/agent/conversation-state.d.ts

@@ -1,14 +1,47 @@
 import type { ChatCompletionMessageParam } from "../utils/llm-client.js";
 import { type NuclearEntry } from "./nuclear-form.js";
-import type { HistoryFile } from "./history-file.js";
+import type { HandlerFunctions } from "../utils/handler-registry.js";
+/** Search hit shape returned by the `history:search` handler. */
+export interface HistoryHit {
+    entry: NuclearEntry;
+    line: string;
+}
+export interface CompactResult {
+    before: number;
+    after: number;
+    evictedCount: number;
+    [extra: string]: unknown;
+}
+/**
+ * Conversation state with eager nucleation — shell-history shaped.
+ *
+ * Every add nucleates into a one-line NuclearEntry and flushes to disk.
+ * Compaction evicts turns, replacing them with their nuclear one-liners
+ * in context; the originals stay searchable via `conversation_recall`
+ * and survive restarts in `~/.agent-sh/history`.
+ *
+ * Nucleation and history I/O go through advisable handlers — extensions
+ * swap strategies without touching this class. When no handlers are
+ * provided (subagents, tests), both become no-ops and this becomes a
+ * plain message buffer.
+ */
 export declare class ConversationState {
     private messages;
+    private messagesDirty;
+    private cachedMessagesJson;
+    private toolErrors;
     private nuclearEntries;
+    private nuclearBySeq;
     private recallArchive;
-    private historyFile;
+    readonly instanceId: string;
+    private readonly handlers;
     private nextSeq;
-    constructor(historyFile?: HistoryFile);
-    get instanceId(): string;
+    private lastApiTokenCount;
+    private lastApiMessageCount;
+    constructor(handlers?: HandlerFunctions, instanceId?: string);
+    /** Get JSON.stringify of messages, cached until next mutation. */
+    private getMessagesJson;
+    private invalidateMessagesCache;
     addUserMessage(text: string): void;
     addAssistantMessage(content: string | null, toolCalls?: {
         id: string;
@@ -17,43 +50,61 @@ export declare class ConversationState {
             arguments: string;
         };
     }[]): void;
-    addToolResult(toolCallId: string, content: string): void;
+    addToolResult(toolCallId: string, content: string, isError?: boolean): void;
     /** Add tool results as a user message (for inline tool protocol). */
     addToolResultInline(content: string): void;
     addSystemNote(text: string): void;
     getMessages(): ChatCompletionMessageParam[];
-    estimateTokens(): number;
     /**
-     * Priority-based compaction. Evicts lowest-priority turns, replacing
-     * them with nuclear one-liner summaries that stay in the conversation.
-     * Read-only tool results are dropped entirely.
+     * Replace the messages array wholesale — the write side for custom
+     * compaction strategies. Invalidates API token baseline since the
+     * new array's token count is unknown.
      */
-    compact(targetTokens: number, recentTurnsToKeep?: number, force?: boolean): {
-        before: number;
-        after: number;
-    } | null;
+    replaceMessages(messages: ChatCompletionMessageParam[]): void;
+    private pruneToolErrors;
+    private eagerNucleateUser;
+    /** Nucleate an agent text response. Called by agent-loop when the loop finishes without tool calls. */
+    eagerNucleateAgent(text: string): void;
+    /** Nucleate tool call results. One entry per tool call, enriched with result. */
+    eagerNucleateTools(results: Array<{
+        toolName: string;
+        args: Record<string, unknown>;
+        content: string;
+        isError: boolean;
+    }>): void;
+    /** Track an entry in memory (nuclear list + recall archive). */
+    private recordNuclearEntry;
+    private appendToHistory;
+    updateApiTokenCount(promptTokens: number): void;
+    estimatePromptTokens(): number;
+    estimateTokens(): number;
     /**
-     * Flush oldest nuclear entries to the history file when the
-     * in-context nuclear block grows too large.
+     * Two-tier pin compaction: evict lowest-priority turns (replaced by
+     * their nuclear one-liners), slim the window before the last verbatim
+     * turn, drop read-only tool results entirely. Extensions replace the
+     * whole strategy by advising `conversation:compact` and skipping next.
      */
-    flush(): Promise<void>;
+    compact(maxPromptTokens: number, recentTurnsToKeep?: number, force?: boolean): CompactResult | null;
     /**
-     * Inject prior session history from the history file as a context note.
+     * Inject prior session history as a context preamble. The preamble
+     * layout goes through the `conversation:format-prior-history` handler,
+     * so extensions can swap the flat list for grouped/richer rendering.
      */
     loadPriorHistory(entries: NuclearEntry[]): void;
-    /** Search Tier 2 archive + Tier 3 history file. */
     search(query: string): Promise<string>;
-    /** Expand full content of a nuclear entry by seq number. */
     expand(seq: number): Promise<string>;
-    /** Browse nuclear entries (Tier 2) + recent history (Tier 3). */
     browse(): Promise<string>;
+    getNuclearEntries(): readonly NuclearEntry[];
     getNuclearEntryCount(): number;
+    getNuclearSummary(): string | null;
     getRecallArchiveSize(): number;
     clear(): void;
     private buildNuclearBlock;
+    /** Index of the nuclear block in messages[], or -1 if not present. */
+    private nuclearBlockIdx;
     private updateNuclearBlockInMessages;
+    private slimTurn;
     private parseTurns;
     private inferPriority;
-    private searchArchive;
     private turnToText;
 }