agent-sh 0.14.8 → 0.14.9

package/dist/agent/live-view.js

@@ -0,0 +1,238 @@
+import { stripMeta } from "./llm-client.js";
+export class LiveView {
+    messages = [];
+    messagesDirty = true;
+    cachedMessagesJson = null;
+    instanceId;
+    handlers;
+    lastApiTokenCount = null;
+    lastApiMessageCount = 0;
+    // Mid-tool-pair user/system messages are buffered and flushed after
+    // the trailing tool_result — splicing into the gap breaks
+    // reasoning_content pairing on strict providers.
+    pendingMessages = [];
+    constructor(handlers, instanceId = "0000") {
+        this.handlers = handlers ?? null;
+        this.instanceId = instanceId;
+    }
+    getMessagesJson() {
+        if (this.messagesDirty || this.cachedMessagesJson === null) {
+            this.cachedMessagesJson = JSON.stringify(this.messages);
+            this.messagesDirty = false;
+        }
+        return this.cachedMessagesJson;
+    }
+    invalidateMessagesCache() {
+        this.messagesDirty = true;
+        this.cachedMessagesJson = null;
+    }
+    addUserMessage(text) {
+        this.messages.push({ role: "user", content: text });
+        this.invalidateMessagesCache();
+    }
+    addAssistantMessage(content, toolCalls, extras) {
+        const hasToolCalls = !!toolCalls?.length;
+        // Promote reasoning into content on reasoning-only turns; strict
+        // providers (DeepSeek native) reject content="" with no tool_calls.
+        if (!content && !hasToolCalls) {
+            const r = (extras?.reasoning_content ?? extras?.reasoning);
+            if (typeof r === "string" && r)
+                content = r;
+        }
+        if (!content && !hasToolCalls)
+            return;
+        const base = {
+            role: "assistant",
+            content: hasToolCalls ? (content ?? null) : content,
+        };
+        if (hasToolCalls) {
+            base.tool_calls = toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: tc.function,
+            }));
+        }
+        if (extras)
+            Object.assign(base, extras);
+        this.messages.push(base);
+        this.invalidateMessagesCache();
+    }
+    addToolResult(toolCallId, content, isError = false) {
+        if (typeof content === "string") {
+            this.messages.push({ role: "tool", tool_call_id: toolCallId, content });
+        }
+        else {
+            const parts = [];
+            for (const img of content) {
+                parts.push({ type: "image_url", image_url: { url: `data:${img.mimeType};base64,${img.data}` } });
+            }
+            const label = isError ? `Error: [${content.length} image(s)]` : `[${content.length} image(s)]`;
+            parts.unshift({ type: "text", text: label });
+            this.messages.push({ role: "tool", tool_call_id: toolCallId, content: parts });
+        }
+        this.invalidateMessagesCache();
+        this.flushPendingMessages();
+    }
+    addToolResultInline(content) {
+        this.messages.push({ role: "user", content });
+        this.invalidateMessagesCache();
+        this.flushPendingMessages();
+    }
+    /** Safe from any context: queues if mid-tool-pair, appends otherwise. */
+    addSystemNote(text) {
+        if (this.hasOpenToolCalls()) {
+            this.pendingMessages.push({ kind: "system", text });
+            return;
+        }
+        this.messages.push({ role: "user", content: text });
+        this.invalidateMessagesCache();
+    }
+    appendUserMessage(text) {
+        if (this.hasOpenToolCalls()) {
+            this.pendingMessages.push({ kind: "user", text });
+            return;
+        }
+        this.addUserMessage(text);
+    }
+    hasOpenToolCalls() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const msg = this.messages[i];
+            if (msg.role === "tool")
+                continue;
+            if (msg.role !== "assistant")
+                return false;
+            if (!("tool_calls" in msg) || !msg.tool_calls)
+                return false;
+            const answered = new Set();
+            for (let j = i + 1; j < this.messages.length; j++) {
+                const m = this.messages[j];
+                if (m.role !== "tool")
+                    break;
+                answered.add(m.tool_call_id);
+            }
+            return msg.tool_calls.some((tc) => !answered.has(tc.id));
+        }
+        return false;
+    }
+    flushPendingMessages() {
+        if (this.pendingMessages.length === 0)
+            return;
+        if (this.hasOpenToolCalls())
+            return;
+        const pending = this.pendingMessages;
+        this.pendingMessages = [];
+        for (const m of pending) {
+            if (m.kind === "user") {
+                this.addUserMessage(m.text);
+            }
+            else {
+                this.messages.push({ role: "user", content: m.text });
+            }
+        }
+        this.invalidateMessagesCache();
+    }
+    getMessages() {
+        return this.normalizeReasoningConsistency(this.stubDanglingToolCalls(this.dropOrphanToolMessages(this.messages)));
+    }
+    get() {
+        return this.messages;
+    }
+    forLLM() {
+        return this.getMessages().map(stripMeta);
+    }
+    replace(msgs) {
+        this.replaceMessages(msgs);
+    }
+    link(index, entryId) {
+        const m = this.messages[index];
+        if (!m)
+            throw new Error(`LiveView.link: no message at index ${index}`);
+        const am = m;
+        am.meta = { ...am.meta, entryId };
+    }
+    /** DeepSeek 400s on tool messages without a matching tool_call;
+     *  compaction can leave such orphans. */
+    dropOrphanToolMessages(messages) {
+        const knownIds = new Set();
+        const result = [];
+        for (const msg of messages) {
+            if (msg.role === "assistant" && "tool_calls" in msg && msg.tool_calls) {
+                for (const tc of msg.tool_calls)
+                    knownIds.add(tc.id);
+            }
+            if (msg.role === "tool" && !knownIds.has(msg.tool_call_id)) {
+                continue;
+            }
+            result.push(msg);
+        }
+        return result;
+    }
+    /** Stub missing tool results after a mid-execution interrupt so
+     *  DeepSeek doesn't 400 on dangling tool_calls. */
+    stubDanglingToolCalls(messages) {
+        const result = [];
+        let i = 0;
+        while (i < messages.length) {
+            const msg = messages[i];
+            result.push(msg);
+            i++;
+            if (msg.role !== "assistant" || !("tool_calls" in msg) || !msg.tool_calls)
+                continue;
+            const seen = new Set();
+            while (i < messages.length && messages[i].role === "tool") {
+                const t = messages[i];
+                seen.add(t.tool_call_id);
+                result.push(t);
+                i++;
+            }
+            for (const tc of msg.tool_calls) {
+                if (!seen.has(tc.id)) {
+                    result.push({ role: "tool", tool_call_id: tc.id, content: "[cancelled]" });
+                }
+            }
+        }
+        return result;
+    }
+    /** DeepSeek 400s if any assistant in a thinking-mode conversation
+     *  is missing `reasoning_content`. Cross-alias `reasoning` (from
+     *  OpenRouter) and stub gaps with "". */
+    normalizeReasoningConsistency(messages) {
+        const needsNormalize = messages.some((m) => m.role === "assistant" && (m.reasoning !== undefined ||
+            m.reasoning_content !== undefined ||
+            m.reasoning_details !== undefined));
+        if (!needsNormalize)
+            return messages;
+        return messages.map((m) => {
+            if (m.role !== "assistant")
+                return m;
+            const a = m;
+            if (a.reasoning_content !== undefined)
+                return m;
+            return { ...m, reasoning_content: a.reasoning ?? "" };
+        });
+    }
+    /** Invalidates the API token baseline since the new array's count is unknown. */
+    replaceMessages(messages) {
+        this.messages = messages;
+        this.invalidateMessagesCache();
+        this.lastApiTokenCount = null;
+        this.lastApiMessageCount = 0;
+        this.flushPendingMessages();
+    }
+    updateApiTokenCount(promptTokens) {
+        this.lastApiTokenCount = promptTokens;
+        this.lastApiMessageCount = this.messages.length;
+    }
+    estimatePromptTokens() {
+        if (this.lastApiTokenCount === null)
+            return this.estimateTokens();
+        const trailing = this.messages.length - this.lastApiMessageCount;
+        if (trailing <= 0)
+            return this.lastApiTokenCount;
+        const trailingMessages = this.messages.slice(this.lastApiMessageCount);
+        return this.lastApiTokenCount + Math.ceil(JSON.stringify(trailingMessages).length / 4);
+    }
+    estimateTokens() {
+        return Math.ceil(this.getMessagesJson().length / 4);
+    }
+}

package/dist/agent/llm-client.d.ts

@@ -11,6 +11,7 @@ export type { ChatCompletionMessageParam, ChatCompletionTool };
 export type AgentShMessage = ChatCompletionMessageParam & {
     meta?: Record<string, unknown>;
 };
+export declare function stripMeta(m: ChatCompletionMessageParam): ChatCompletionMessageParam;
 export interface LlmClientConfig {
     apiKey: string;
     baseURL?: string;

package/dist/agent/llm-client.js

@@ -6,7 +6,7 @@
  * (command suggestions, completions).
  */
 import OpenAI from "openai";
-function stripMeta(m) {
+export function stripMeta(m) {
     if (!("meta" in m))
         return m;
     const { meta: _meta, ...rest } = m;

package/dist/agent/session-store.d.ts

@@ -0,0 +1,90 @@
+import type { AgentShMessage } from "./llm-client.js";
+export type { AgentShMessage } from "./llm-client.js";
+export interface SessionHeaderEntry {
+    type: "session";
+    id: string;
+    parentId: null;
+    timestamp: number;
+    cwd: string;
+    version: 1;
+}
+export interface MessageEntry {
+    type: "message";
+    id: string;
+    parentId: string;
+    timestamp: number;
+    message: AgentShMessage;
+}
+export interface CompactionEntry {
+    type: "compaction";
+    id: string;
+    parentId: string;
+    timestamp: number;
+    firstKeptId: string;
+    tokensBefore: number;
+    summary?: string;
+}
+/** Omitted from buildMessages — the agent already saw it via <shell_events>. */
+export interface ShellExchangeEntry {
+    type: "shell-exchange";
+    id: string;
+    parentId: string;
+    timestamp: number;
+    command: string;
+    output: string;
+    exitCode: number | null;
+    cwd?: string;
+    private?: boolean;
+}
+export type SessionEntry = SessionHeaderEntry | MessageEntry | CompactionEntry | ShellExchangeEntry;
+export declare function newEntryId(): string;
+export declare function summarizeMessage(m: AgentShMessage): string;
+/** For displayed user text. Loops because both wrappers can stack at the head. */
+export declare function stripContextWrappers(content: string): string;
+export declare function renderEvictedSummary(evicted: AgentShMessage[]): string;
+export declare class SessionStore {
+    private entriesPath;
+    private leafPath;
+    private entries;
+    private rootId;
+    private activeLeaf;
+    private pendingHeader;
+    readonly id: string;
+    constructor(filePath: string, opts?: {
+        create?: {
+            cwd: string;
+            sessionId: string;
+        };
+    });
+    /** Deferred so an opened-but-unused session leaves no files on disk. */
+    private flushHeader;
+    getActiveLeaf(): string;
+    setActiveLeaf(id: string): void;
+    getRootId(): string;
+    getEntry(id: string): SessionEntry | undefined;
+    getAllEntries(): SessionEntry[];
+    appendMessages(messages: AgentShMessage[]): Promise<string[]>;
+    appendShellExchange(e: {
+        command: string;
+        output: string;
+        exitCode: number | null;
+        cwd?: string;
+        private?: boolean;
+    }): Promise<string>;
+    appendCompaction(firstKeptId: string, tokensBefore: number, summary?: string): Promise<string>;
+    /** Returns oldest-first. */
+    getBranch(leafId?: string): SessionEntry[];
+    /** Latest compaction on the branch replaces the evicted prefix with
+     *  its stored summary, or a rendered one if no summary was stored. */
+    buildMessages(leafId?: string): AgentShMessage[];
+    /** Parallel entryIds array — null for the synthetic compaction-summary
+     *  slot — so callers can map message indices back to on-disk ids. */
+    buildBranchWithIds(leafId?: string): {
+        messages: AgentShMessage[];
+        entryIds: (string | null)[];
+    };
+    getPreview(): string;
+    private load;
+    private lastEntryId;
+    private persistLeaf;
+}

package/dist/agent/session-store.js

@@ -0,0 +1,288 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+export function newEntryId() {
+    return crypto.randomBytes(4).toString("hex");
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((p) => {
+            if (typeof p === "string")
+                return p;
+            const part = p;
+            return part?.text ?? part?.content ?? "";
+        }).join(" ");
+    }
+    return "";
+}
+function snippet(text, max) {
+    const cleaned = String(text ?? "").replace(/\s+/g, " ").trim();
+    if (cleaned.length <= max)
+        return cleaned || "(empty)";
+    return cleaned.slice(0, max) + "…";
+}
+export function summarizeMessage(m) {
+    const role = m.role ?? "?";
+    if (role === "assistant") {
+        const tc = m.tool_calls;
+        if (Array.isArray(tc) && tc.length > 0) {
+            const tools = tc.map((t) => {
+                const name = t.function?.name ?? "tool";
+                const args = t.function?.arguments;
+                return args ? `${name}(${snippet(args, 200)})` : name;
+            }).join(", ");
+            const text = extractText(m.content);
+            const prefix = text ? `${snippet(text, 400)} → ` : "";
+            return `assistant: ${prefix}called ${tools}`;
+        }
+    }
+    if (role === "tool") {
+        const text = typeof m.content === "string" ? m.content : extractText(m.content);
+        const isErr = /^error\b|: error\b/i.test(text.slice(0, 200));
+        return `tool result: ${snippet(text, isErr ? 1000 : 400)}`;
+    }
+    if (role === "user") {
+        return `user: ${snippet(extractText(m.content), 1000)}`;
+    }
+    return `${role}: ${snippet(extractText(m.content), 500)}`;
+}
+/** For displayed user text. Loops because both wrappers can stack at the head. */
+export function stripContextWrappers(content) {
+    let out = content;
+    for (;;) {
+        const next = out.replace(/^\s*<(query_context|dynamic_context)>[\s\S]*?<\/\1>\s*/, "");
+        if (next === out)
+            return out;
+        out = next;
+    }
+}
+export function renderEvictedSummary(evicted) {
+    const lines = evicted.map((m) => `- ${summarizeMessage(m)}`);
+    return `${lines.length} message(s) elided\n${lines.join("\n")}`;
+}
+export class SessionStore {
+    entriesPath;
+    leafPath;
+    entries = new Map();
+    rootId = "";
+    activeLeaf = "";
+    pendingHeader = null;
+    id;
+    constructor(filePath, opts) {
+        this.entriesPath = filePath;
+        this.leafPath = filePath + ".leaf";
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        if (opts?.create) {
+            this.id = opts.create.sessionId;
+            const header = {
+                type: "session",
+                id: opts.create.sessionId,
+                parentId: null,
+                timestamp: Date.now(),
+                cwd: opts.create.cwd,
+                version: 1,
+            };
+            this.entries.set(header.id, header);
+            this.rootId = header.id;
+            this.activeLeaf = header.id;
+            this.pendingHeader = header;
+        }
+        else {
+            this.id = "";
+            this.load();
+            if (!this.rootId)
+                throw new Error(`session file lacks a session header: ${filePath}`);
+            this.id = this.rootId;
+        }
+    }
+    /** Deferred so an opened-but-unused session leaves no files on disk. */
+    flushHeader() {
+        if (!this.pendingHeader)
+            return;
+        const headerLine = JSON.stringify(this.pendingHeader) + "\n";
+        this.pendingHeader = null;
+        fs.writeFileSync(this.entriesPath, headerLine);
+        this.persistLeaf();
+    }
+    getActiveLeaf() { return this.activeLeaf; }
+    setActiveLeaf(id) {
+        if (!this.entries.has(id))
+            throw new Error(`unknown entry: ${id}`);
+        this.activeLeaf = id;
+        this.persistLeaf();
+    }
+    getRootId() { return this.rootId; }
+    getEntry(id) { return this.entries.get(id); }
+    getAllEntries() { return [...this.entries.values()]; }
+    async appendMessages(messages) {
+        if (messages.length === 0)
+            return [];
+        this.flushHeader();
+        let parent = this.activeLeaf;
+        const lines = [];
+        const newIds = [];
+        for (const m of messages) {
+            const e = {
+                type: "message",
+                id: newEntryId(),
+                parentId: parent,
+                timestamp: Date.now(),
+                message: m,
+            };
+            this.entries.set(e.id, e);
+            lines.push(JSON.stringify(e));
+            newIds.push(e.id);
+            parent = e.id;
+        }
+        this.activeLeaf = parent;
+        await fsp.appendFile(this.entriesPath, lines.join("\n") + "\n");
+        this.persistLeaf();
+        return newIds;
+    }
+    async appendShellExchange(e) {
+        this.flushHeader();
+        const entry = {
+            type: "shell-exchange",
+            id: newEntryId(),
+            parentId: this.activeLeaf,
+            timestamp: Date.now(),
+            command: e.command,
+            output: e.output,
+            exitCode: e.exitCode,
+            ...(e.cwd !== undefined ? { cwd: e.cwd } : {}),
+            ...(e.private ? { private: true } : {}),
+        };
+        this.entries.set(entry.id, entry);
+        this.activeLeaf = entry.id;
+        await fsp.appendFile(this.entriesPath, JSON.stringify(entry) + "\n");
+        this.persistLeaf();
+        return entry.id;
+    }
+    async appendCompaction(firstKeptId, tokensBefore, summary) {
+        if (!this.entries.has(firstKeptId))
+            throw new Error(`firstKeptId unknown: ${firstKeptId}`);
+        this.flushHeader();
+        const e = {
+            type: "compaction",
+            id: newEntryId(),
+            parentId: this.activeLeaf,
+            timestamp: Date.now(),
+            firstKeptId,
+            tokensBefore,
+            ...(summary !== undefined ? { summary } : {}),
+        };
+        this.entries.set(e.id, e);
+        this.activeLeaf = e.id;
+        await fsp.appendFile(this.entriesPath, JSON.stringify(e) + "\n");
+        this.persistLeaf();
+        return e.id;
+    }
+    /** Returns oldest-first. */
+    getBranch(leafId = this.activeLeaf) {
+        const out = [];
+        const seen = new Set();
+        let cur = leafId;
+        while (cur && !seen.has(cur)) {
+            seen.add(cur);
+            const e = this.entries.get(cur);
+            if (!e)
+                break;
+            out.push(e);
+            cur = e.parentId;
+        }
+        return out.reverse();
+    }
+    /** Latest compaction on the branch replaces the evicted prefix with
+     *  its stored summary, or a rendered one if no summary was stored. */
+    buildMessages(leafId = this.activeLeaf) {
+        return this.buildBranchWithIds(leafId).messages;
+    }
+    /** Parallel entryIds array — null for the synthetic compaction-summary
+     *  slot — so callers can map message indices back to on-disk ids. */
+    buildBranchWithIds(leafId = this.activeLeaf) {
+        const branch = this.getBranch(leafId);
+        let compactionIdx = -1;
+        for (let i = branch.length - 1; i >= 0; i--) {
+            if (branch[i].type === "compaction") {
+                compactionIdx = i;
+                break;
+            }
+        }
+        const messages = [];
+        const entryIds = [];
+        let startIdx = 0;
+        if (compactionIdx >= 0) {
+            const c = branch[compactionIdx];
+            const firstKeptIdx = branch.findIndex((e) => e.id === c.firstKeptId);
+            startIdx = firstKeptIdx >= 0 ? firstKeptIdx : 0;
+            const summary = c.summary ?? renderEvictedSummary(branch.slice(0, startIdx)
+                .filter((e) => e.type === "message")
+                .map((e) => e.message));
+            messages.push({ role: "user", content: `[Compacted conversation summary]\n${summary}` });
+            entryIds.push(null);
+        }
+        for (let i = startIdx; i < branch.length; i++) {
+            const e = branch[i];
+            if (e.type === "message") {
+                messages.push(e.message);
+                entryIds.push(e.id);
+            }
+        }
+        return { messages, entryIds };
+    }
+    getPreview() {
+        for (const e of this.entries.values()) {
+            if (e.type === "message" && e.message.role === "user") {
+                const raw = typeof e.message.content === "string" ? e.message.content : "";
+                const txt = stripContextWrappers(raw);
+                if (txt)
+                    return txt.slice(0, 80);
+            }
+        }
+        return "(empty)";
+    }
+    load() {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.entriesPath, "utf-8");
+        }
+        catch {
+            return;
+        }
+        for (const line of raw.split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const e = JSON.parse(line);
+                if (!e.id)
+                    continue;
+                this.entries.set(e.id, e);
+                if (e.type === "session")
+                    this.rootId = e.id;
+            }
+            catch { /* skip malformed */ }
+        }
+        try {
+            this.activeLeaf = fs.readFileSync(this.leafPath, "utf-8").trim();
+            if (!this.entries.has(this.activeLeaf))
+                this.activeLeaf = this.rootId;
+        }
+        catch {
+            this.activeLeaf = this.lastEntryId();
+        }
+    }
+    lastEntryId() {
+        let lastId = this.rootId;
+        for (const e of this.entries.values())
+            lastId = e.id;
+        return lastId;
+    }
+    persistLeaf() {
+        if (this.pendingHeader)
+            return;
+        fs.writeFileSync(this.leafPath, this.activeLeaf);
+    }
+}