agent-sh 0.14.8 → 0.14.9

package/dist/agent/extensions/rolling-history/strategy.d.ts

@@ -0,0 +1,70 @@
+import type { Store, Entry } from "../../store.js";
+import type { AgentShMessage } from "../../llm-client.js";
+import { type NuclearEntry } from "../../nuclear-form.js";
+export interface SummaryCtx {
+    store: Store;
+    bus: {
+        on(event: "conversation:message-appended", fn: MessageAppendedHandler): void;
+    };
+    advise(op: "conversation:compact", fn: CompactAdvisor): void;
+    /** Process id — disambiguates cross-instance entries in `nucleate()`. */
+    iid: string;
+    getMessages(): AgentShMessage[];
+    replaceMessages(msgs: AgentShMessage[]): void;
+    estimateTokens(): number;
+    estimatePromptTokens(): number;
+    linkMessage(index: number, entryId: string): void;
+}
+export interface MessageAppendedEvent {
+    role: "user" | "assistant" | "tool" | "system";
+    content: string;
+    toolName?: string;
+    toolArgs?: Record<string, unknown>;
+    isError?: boolean;
+}
+export type MessageAppendedHandler = (e: MessageAppendedEvent) => Promise<void> | void;
+export interface CompactEvent {
+    target?: number;
+    force?: boolean;
+    /** `rewind`/`replace` are kernel-owned manual edits — the summary
+     *  strategy delegates them via `next()`. */
+    strategy?: {
+        kind: "two-tier-pin";
+        target: number;
+        keepRecent?: number;
+        force?: boolean;
+    } | {
+        kind: "rewind";
+        toIndex: number;
+    } | {
+        kind: "replace";
+        messages: unknown[];
+    };
+}
+export interface CompactResult {
+    before: number;
+    after: number;
+    evictedCount: number;
+}
+export type CompactAdvisor = (next: (e: CompactEvent) => Promise<CompactResult | null>, event: CompactEvent) => Promise<CompactResult | null>;
+export declare function activate(ctx: SummaryCtx): void;
+export declare function makeCaptureHandler(ctx: SummaryCtx): MessageAppendedHandler;
+export declare function nuclearToEntry(ne: NuclearEntry, id: string): Entry;
+export declare function makeCompactAdvisor(ctx: SummaryCtx): CompactAdvisor;
+export declare enum Priority {
+    LOWEST = 0,// large read-only tool results
+    LOW = 1,// successful tool results
+    MEDIUM = 2,// write/edit tool results, plain assistant turns
+    HIGH = 3,// user messages, errors
+    PINNED = 4
+}
+export interface Turn {
+    messages: AgentShMessage[];
+    priority: Priority;
+}
+/** A new turn starts at each user message; the first may be headless
+ *  (system, preamble). */
+export declare function parseTurns(msgs: AgentShMessage[]): Turn[];
+export declare function inferPriority(msgs: AgentShMessage[]): Priority;
+export declare function slimTurn(messages: AgentShMessage[]): AgentShMessage[];
+export declare function readSummaryLines(store: Store, n?: number): Promise<string[]>;

package/dist/agent/extensions/rolling-history/strategy.js

@@ -0,0 +1,336 @@
+import { newEntryId } from "../../store.js";
+import { nucleate, READ_ONLY_TOOLS, WRITE_TOOLS, isReadOnly, } from "../../nuclear-form.js";
+import { formatEntryLine } from "../../entry-format.js";
+import { RECALL_CACHE_KIND } from "./constants.js";
+export function activate(ctx) {
+    ctx.bus.on("conversation:message-appended", makeCaptureHandler(ctx));
+    ctx.advise("conversation:compact", makeCompactAdvisor(ctx));
+}
+export function makeCaptureHandler(ctx) {
+    return async (e) => {
+        const store = ctx.store;
+        // Capture the index synchronously — later async ticks may grow the array.
+        const msgs = ctx.getMessages();
+        const liveIdx = msgs.length - 1;
+        const m = msgs[liveIdx];
+        if (!m)
+            return;
+        // Stamp meta.tool so compact's inferPriority can read it without
+        // walking back to the event payload.
+        if (e.role === "tool" && e.toolName !== undefined) {
+            m.meta = {
+                ...m.meta,
+                tool: { toolName: e.toolName, args: e.toolArgs ?? {}, isError: !!e.isError },
+            };
+        }
+        const ne = nucleateFromEvent(e, ctx.iid);
+        if (!ne)
+            return;
+        const id = newEntryId();
+        await store.append([nuclearToEntry(ne, id)]);
+        await store.append([{
+                id: newEntryId(), parentId: id, ts: Date.now(),
+                kind: RECALL_CACHE_KIND,
+                payload: { fullMessage: m },
+            }], { ephemeral: true });
+        ctx.linkMessage(liveIdx, id);
+    };
+}
+function nucleateFromEvent(e, iid) {
+    if (e.role === "user") {
+        if (!e.content)
+            return null;
+        return nucleate("user", e.content, iid, 0);
+    }
+    if (e.role === "assistant") {
+        if (!e.content)
+            return null;
+        return nucleate("agent", e.content, iid, 0);
+    }
+    if (e.role === "tool") {
+        if (e.toolName === undefined)
+            return null;
+        return nucleate("tool", e.toolName, e.toolArgs ?? {}, e.content, !!e.isError, iid, 0);
+    }
+    return null;
+}
+/** Used during compact when topping up summaries for messages that
+ *  missed eager capture (e.g. injected system notes that bypassed the
+ *  event). Reads from message structure rather than an event payload. */
+function nucleateFromMessage(m, iid) {
+    if (m.role === "user") {
+        const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content ?? "");
+        if (!text)
+            return null;
+        return nucleate("user", text, iid, 0);
+    }
+    if (m.role === "assistant") {
+        if ("tool_calls" in m && m.tool_calls && m.tool_calls.length > 0)
+            return null;
+        const text = typeof m.content === "string" ? m.content : "";
+        if (!text)
+            return null;
+        return nucleate("agent", text, iid, 0);
+    }
+    if (m.role === "tool") {
+        const tool = m.meta?.tool;
+        if (!tool)
+            return null;
+        const content = typeof m.content === "string" ? m.content : "";
+        return nucleate("tool", tool.toolName, tool.args, content, tool.isError ?? false, iid, 0);
+    }
+    return null;
+}
+export function nuclearToEntry(ne, id) {
+    const { seq: _seq, ts, kind, ...rest } = ne;
+    return { id, ts, kind, payload: rest };
+}
+const DEFAULT_RECENT_TURNS_KEEP = 10;
+export function makeCompactAdvisor(ctx) {
+    return async (next, event) => {
+        if (event.strategy?.kind === "rewind" || event.strategy?.kind === "replace") {
+            return next(event);
+        }
+        const promptBefore = ctx.estimatePromptTokens();
+        const convBefore = ctx.estimateTokens();
+        const overhead = Math.max(0, promptBefore - convBefore);
+        const promptTarget = event.target ?? Infinity;
+        const convTarget = Math.max(0, promptTarget - overhead);
+        if (!event.force && promptBefore <= promptTarget)
+            return null;
+        const msgs = ctx.getMessages();
+        const turns = parseTurns(msgs);
+        const minTurns = event.force ? 1 : 2;
+        if (turns.length <= minTurns)
+            return null;
+        const maxPinnedFraction = event.force ? 0.4 : 0.6;
+        const maxPinned = Math.max(2, Math.floor(turns.length * maxPinnedFraction));
+        const recentKeep = Math.min(DEFAULT_RECENT_TURNS_KEEP, turns.length - 1, Math.max(1, event.force ? Math.min(maxPinned, turns.length - 2) : maxPinned));
+        for (const t of turns)
+            t.priority = inferPriority(t.messages);
+        const verbatimCount = 1;
+        const slimmedCount = Math.max(0, recentKeep - verbatimCount);
+        const slimStart = turns.length - recentKeep;
+        const slimEnd = slimStart + slimmedCount;
+        const slimmedIndices = new Set();
+        for (let i = slimStart; i < slimEnd; i++)
+            slimmedIndices.add(i);
+        turns[0].priority = Priority.PINNED;
+        for (let i = turns.length - verbatimCount; i < turns.length; i++)
+            turns[i].priority = Priority.PINNED;
+        for (const i of slimmedIndices)
+            turns[i].priority = Priority.PINNED;
+        const candidates = turns
+            .map((t, idx) => ({ turn: t, idx }))
+            .filter((c) => c.turn.priority !== Priority.PINNED)
+            .sort((a, b) => {
+            const wA = a.turn.priority * recencyWeight(a.idx, turns.length);
+            const wB = b.turn.priority * recencyWeight(b.idx, turns.length);
+            return wA - wB || a.idx - b.idx;
+        });
+        const evicted = new Set();
+        let tokens = convBefore;
+        const newSummaryEntries = [];
+        const newCacheEntries = [];
+        const store = ctx.store;
+        for (const c of candidates) {
+            if (tokens <= convTarget)
+                break;
+            evicted.add(c.idx);
+            tokens -= estimateTurnTokens(c.turn.messages);
+            // Top up summaries for messages that missed eager capture.
+            // Read-only tools are cached ephemerally only — the agent can
+            // re-read the source.
+            for (const m of c.turn.messages) {
+                const existingId = m.meta?.entryId;
+                if (existingId) {
+                    newCacheEntries.push({
+                        id: newEntryId(), parentId: existingId, ts: Date.now(),
+                        kind: RECALL_CACHE_KIND,
+                        payload: { fullMessage: m },
+                    });
+                    continue;
+                }
+                const ne = nucleateFromMessage(m, ctx.iid);
+                if (!ne)
+                    continue;
+                const id = newEntryId();
+                const entry = nuclearToEntry(ne, id);
+                if (!isReadOnly(ne)) {
+                    newSummaryEntries.push(entry);
+                }
+                newCacheEntries.push({
+                    id: newEntryId(), parentId: id, ts: Date.now(),
+                    kind: RECALL_CACHE_KIND,
+                    payload: { fullMessage: m },
+                });
+            }
+        }
+        if (evicted.size === 0)
+            return null;
+        if (newSummaryEntries.length > 0)
+            await store.append(newSummaryEntries);
+        if (newCacheEntries.length > 0)
+            await store.append(newCacheEntries, { ephemeral: true });
+        const rebuilt = [];
+        let blockInserted = false;
+        for (let i = 0; i < turns.length; i++) {
+            if (evicted.has(i)) {
+                if (!blockInserted) {
+                    rebuilt.push(await buildSummaryBlock(store));
+                    blockInserted = true;
+                }
+                continue;
+            }
+            if (slimmedIndices.has(i)) {
+                rebuilt.push(...slimTurn(turns[i].messages));
+            }
+            else {
+                rebuilt.push(...turns[i].messages);
+            }
+        }
+        ctx.replaceMessages(rebuilt);
+        const after = ctx.estimatePromptTokens();
+        return { before: promptBefore, after, evictedCount: evicted.size };
+    };
+}
+export var Priority;
+(function (Priority) {
+    Priority[Priority["LOWEST"] = 0] = "LOWEST";
+    Priority[Priority["LOW"] = 1] = "LOW";
+    Priority[Priority["MEDIUM"] = 2] = "MEDIUM";
+    Priority[Priority["HIGH"] = 3] = "HIGH";
+    Priority[Priority["PINNED"] = 4] = "PINNED";
+})(Priority || (Priority = {}));
+/** A new turn starts at each user message; the first may be headless
+ *  (system, preamble). */
+export function parseTurns(msgs) {
+    const turns = [];
+    let current = [];
+    for (const m of msgs) {
+        if (m.role === "user" && current.length > 0) {
+            turns.push({ messages: current, priority: Priority.MEDIUM });
+            current = [];
+        }
+        current.push(m);
+    }
+    if (current.length > 0)
+        turns.push({ messages: current, priority: Priority.MEDIUM });
+    return turns;
+}
+export function inferPriority(msgs) {
+    let hasError = false;
+    let hasWriteTool = false;
+    let allReadOnly = true;
+    let hasToolResult = false;
+    for (const m of msgs) {
+        if (m.role === "user")
+            return Priority.HIGH;
+        if (m.role === "tool") {
+            hasToolResult = true;
+            const tool = m.meta?.tool;
+            const content = typeof m.content === "string" ? m.content : "";
+            if (tool?.isError || content.startsWith("Error:"))
+                hasError = true;
+        }
+        if (m.role === "assistant" && "tool_calls" in m && m.tool_calls) {
+            for (const tc of m.tool_calls) {
+                const fn = "function" in tc ? tc.function : undefined;
+                if (!fn)
+                    continue;
+                if (WRITE_TOOLS.has(fn.name))
+                    hasWriteTool = true;
+                if (!READ_ONLY_TOOLS.has(fn.name))
+                    allReadOnly = false;
+            }
+        }
+    }
+    if (hasError)
+        return Priority.HIGH;
+    if (hasWriteTool)
+        return Priority.MEDIUM;
+    if (hasToolResult && allReadOnly)
+        return Priority.LOWEST;
+    if (hasToolResult)
+        return Priority.LOW;
+    return Priority.MEDIUM;
+}
+function recencyWeight(idx, total) {
+    return Math.max(0.1, 1 - idx / total);
+}
+function estimateTurnTokens(msgs) {
+    return Math.ceil(JSON.stringify(msgs).length / 4);
+}
+export function slimTurn(messages) {
+    const MAX_RESULT_LEN = 1500;
+    const MAX_ASSISTANT_LEN = 1500;
+    const result = [];
+    const droppedToolIds = new Set();
+    for (const msg of messages) {
+        if (msg.role === "assistant" && "tool_calls" in msg && msg.tool_calls) {
+            const kept = msg.tool_calls.filter((tc) => {
+                if (!("function" in tc))
+                    return true;
+                if (READ_ONLY_TOOLS.has(tc.function.name)) {
+                    droppedToolIds.add(tc.id);
+                    return false;
+                }
+                return true;
+            });
+            if (kept.length === 0) {
+                const text = typeof msg.content === "string" ? msg.content.trim() : "";
+                if (!text)
+                    continue;
+                const { tool_calls: _tc, ...rest } = msg;
+                result.push(rest);
+            }
+            else {
+                result.push({ ...msg, tool_calls: kept });
+            }
+            continue;
+        }
+        if (msg.role === "tool") {
+            if (droppedToolIds.has(msg.tool_call_id))
+                continue;
+            const content = typeof msg.content === "string" ? msg.content : "";
+            if (content.length > MAX_RESULT_LEN) {
+                result.push({ ...msg, content: slimToolContent(content, MAX_RESULT_LEN) });
+            }
+            else {
+                result.push(msg);
+            }
+            continue;
+        }
+        if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.length > MAX_ASSISTANT_LEN) {
+            const head = msg.content.slice(0, Math.floor(MAX_ASSISTANT_LEN * 0.6));
+            const tail = msg.content.slice(-Math.floor(MAX_ASSISTANT_LEN * 0.2));
+            const trimmed = msg.content.length - head.length - tail.length;
+            result.push({ ...msg, content: `${head}\n... [${trimmed} chars trimmed by compact]\n${tail}` });
+            continue;
+        }
+        result.push(msg);
+    }
+    return result;
+}
+function slimToolContent(content, maxLen) {
+    const exitMatch = content.match(/exit code:?\s*(\d+)/i);
+    const exitSuffix = exitMatch ? ` (exit ${exitMatch[1]})` : "";
+    const lines = content.split("\n");
+    if (lines.length > 6) {
+        const head = lines.slice(0, 3).join("\n");
+        const tail = lines.slice(-2).join("\n");
+        return `${head}\n... [${lines.length - 5} lines trimmed by compact]\n${tail}${exitSuffix}`;
+    }
+    return `${content.slice(0, maxLen)}\n... [${content.length - maxLen} chars trimmed by compact]${exitSuffix}`;
+}
+export async function readSummaryLines(store, n) {
+    const recent = await store.readRecent(n);
+    return recent.filter((e) => e.kind !== RECALL_CACHE_KIND).map(formatEntryLine);
+}
+async function buildSummaryBlock(store) {
+    const lines = await readSummaryLines(store);
+    return {
+        role: "user",
+        content: `[Conversation history — use conversation_recall to expand any entry]\n${lines.join("\n")}`,
+    };
+}

package/dist/agent/host-types.d.ts

@@ -1,5 +1,4 @@
 import type { CoreConfig, CoreContext } from "../core/types.js";
-import type { HistoryAdapter } from "./history-file.js";
 import type { SkillView, ToolDefinition, ToolExecutionContext, ToolSchemaView } from "./types.js";
 /**
  * Backend-agnostic LLM interface exposed via `ctx.agent.llm`. Fulfilled
@@ -142,7 +141,5 @@ export interface AgentConfigSurface {
     provider?: string;
     /** Default model id. */
     model?: string;
-    /** Conversation history backend. Defaults to the on-disk HistoryFile. */
-    history?: HistoryAdapter;
 }
 export type AgentConfig = CoreConfig & AgentConfigSurface;

package/dist/agent/index.js

@@ -7,7 +7,7 @@ import { AgentLoop } from "./agent-loop.js";
 import { LlmClient } from "./llm-client.js";
 import { createLlmFacade } from "./llm-facade.js";
 import { registerReadOnlyTool, unregisterReadOnlyTool } from "./nuclear-form.js";
-import { resolveProvider, getProviderNames, getSettings } from "../core/settings.js";
+import { resolveProvider, getProviderNames, getSettings, setSessionOverlay, clearSessionOverlay, getSettingSource, } from "../core/settings.js";
 import { resolveApiKey } from "../cli/auth/keys.js";
 import { discoverSkills } from "./skills.js";
 import activateOpenrouter from "./providers/openrouter.js";
@@ -209,7 +209,6 @@ export default function agentBackend(ctx) {
     ctx.define("provider:resolve-api-key", (id) => resolveApiKey(id));
     // Core tools register at activate — before extensions load — so
     // extensions that look them up at activate time (e.g. scheme.ts) find them.
-    // conversation_recall stays in AgentLoop (needs session state).
     const fileReadCache = new Map();
     ctx.define("agent:file-read-cache", () => fileReadCache);
     const getCwd = () => ctx.call("cwd");
@@ -387,14 +386,54 @@ export default function agentBackend(ctx) {
                     initialMode,
                     compositor: ctx.shell?.compositor,
                     instanceId: ctx.instanceId,
-                    history: config.history,
                 });
                 agentLoop.wire();
                 ashActive = true;
                 bus.emit("command:register", {
                     name: "/compact",
-                    description: "Compact conversation via the active compaction strategy",
-                    handler: () => bus.emit("agent:compact-request", {}),
+                    description: "Compact now, or: off | on | threshold <0..1> | status",
+                    handler: (args) => {
+                        const trimmed = args.trim();
+                        if (!trimmed) {
+                            bus.emit("agent:compact-request", {});
+                            return;
+                        }
+                        const [sub, ...rest] = trimmed.split(/\s+/);
+                        if (sub === "off" || sub === "on") {
+                            setSessionOverlay({ autoCompact: sub === "on" });
+                            bus.emit("ui:info", { message: `auto-compact: ${sub} (session)` });
+                            return;
+                        }
+                        if (sub === "threshold") {
+                            const raw = rest[0];
+                            const n = Number(raw);
+                            if (!raw || !Number.isFinite(n) || n < 0 || n > 1) {
+                                bus.emit("ui:error", { message: "usage: /compact threshold <0.0..1.0>" });
+                                return;
+                            }
+                            setSessionOverlay({ autoCompactThreshold: n });
+                            bus.emit("ui:info", { message: `auto-compact threshold: ${n} (session)` });
+                            return;
+                        }
+                        if (sub === "reset") {
+                            clearSessionOverlay("autoCompact", "autoCompactThreshold");
+                            bus.emit("ui:info", { message: "auto-compact: session overrides cleared" });
+                            return;
+                        }
+                        if (sub === "status") {
+                            const s = getSettings();
+                            const enabledSrc = getSettingSource("autoCompact");
+                            const thSrc = getSettingSource("autoCompactThreshold");
+                            bus.emit("ui:info", {
+                                message: `auto-compact: ${s.autoCompact ? "on" : "off"} (${enabledSrc}), ` +
+                                    `threshold: ${s.autoCompactThreshold} (${thSrc})`,
+                            });
+                            return;
+                        }
+                        bus.emit("ui:error", {
+                            message: `unknown subcommand: ${sub}. usage: /compact [off|on|threshold <0..1>|reset|status]`,
+                        });
+                    },
                 });
                 bus.emit("command:register", {
                     name: "/context",

package/dist/agent/live-view.d.ts

@@ -0,0 +1,57 @@
+import type { ChatCompletionMessageParam, AgentShMessage } from "./llm-client.js";
+import type { HandlerFunctions } from "../utils/handler-registry.js";
+import type { ImageContent } from "./types.js";
+export interface CompactResult {
+    before: number;
+    after: number;
+    evictedCount: number;
+    [extra: string]: unknown;
+}
+export declare class LiveView {
+    private messages;
+    private messagesDirty;
+    private cachedMessagesJson;
+    readonly instanceId: string;
+    private readonly handlers;
+    private lastApiTokenCount;
+    private lastApiMessageCount;
+    private pendingMessages;
+    constructor(handlers?: HandlerFunctions, instanceId?: string);
+    private getMessagesJson;
+    private invalidateMessagesCache;
+    addUserMessage(text: string): void;
+    addAssistantMessage(content: string | null, toolCalls?: {
+        id: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[], extras?: Record<string, unknown>): void;
+    addToolResult(toolCallId: string, content: string | ImageContent[], isError?: boolean): void;
+    addToolResultInline(content: string): void;
+    /** Safe from any context: queues if mid-tool-pair, appends otherwise. */
+    addSystemNote(text: string): void;
+    appendUserMessage(text: string): void;
+    private hasOpenToolCalls;
+    private flushPendingMessages;
+    getMessages(): ChatCompletionMessageParam[];
+    get(): AgentShMessage[];
+    forLLM(): ChatCompletionMessageParam[];
+    replace(msgs: AgentShMessage[]): void;
+    link(index: number, entryId: string): void;
+    /** DeepSeek 400s on tool messages without a matching tool_call;
+     *  compaction can leave such orphans. */
+    private dropOrphanToolMessages;
+    /** Stub missing tool results after a mid-execution interrupt so
+     *  DeepSeek doesn't 400 on dangling tool_calls. */
+    private stubDanglingToolCalls;
+    /** DeepSeek 400s if any assistant in a thinking-mode conversation
+     *  is missing `reasoning_content`. Cross-alias `reasoning` (from
+     *  OpenRouter) and stub gaps with "". */
+    private normalizeReasoningConsistency;
+    /** Invalidates the API token baseline since the new array's count is unknown. */
+    replaceMessages(messages: ChatCompletionMessageParam[]): void;
+    updateApiTokenCount(promptTokens: number): void;
+    estimatePromptTokens(): number;
+    estimateTokens(): number;
+}