agent-sh 0.7.0 → 0.9.0

package/dist/utils/handler-registry.js

@@ -11,42 +11,78 @@
  *     if (lang === "latex") return renderLatex(code);
  *     return next(lang, code);  // call original
  *   });
+ *
+ * Internally, each handler is stored as a base function plus an ordered
+ * list of advisors. `call` builds the chain on invocation, so advisors
+ * can be added or removed at any time without closure entanglement.
  */
-/* eslint-disable @typescript-eslint/no-explicit-any */
 export class HandlerRegistry {
-    handlers = new Map();
+    entries = new Map();
     /**
-     * Register a named handler. If one already exists, it's replaced.
+     * Register a named handler. If one already exists, its base is replaced
+     * but existing advisors are preserved.
      */
     define(name, fn) {
-        this.handlers.set(name, fn);
+        const existing = this.entries.get(name);
+        if (existing) {
+            existing.base = fn;
+        }
+        else {
+            this.entries.set(name, { base: fn, advisors: [] });
+        }
     }
     /**
-     * Wrap a named handler with advice. The wrapper receives the
-     * previous handler as `next` and all original arguments.
+     * Add an advisor to a named handler. The advisor receives `next`
+     * (the rest of the chain) and all original arguments.
      *
-     * - Call `next(...args)` to invoke the original (around/before/after)
+     * - Call `next(...args)` to invoke the rest of the chain
      * - Don't call `next` to replace entirely (override)
      * - Call `next` conditionally to wrap (around)
      *
-     * Multiple advisors chain: each wraps the previous one.
-     * If no handler exists yet, `next` is a no-op.
+     * Advisors run outermost-first (last added = outermost).
+     * Returns an unadvise function that cleanly removes this advisor.
      */
-    advise(name, wrapper) {
-        const original = this.handlers.get(name) ?? (() => undefined);
-        this.handlers.set(name, (...args) => wrapper(original, ...args));
+    advise(name, advisor) {
+        let entry = this.entries.get(name);
+        if (!entry) {
+            entry = { base: (() => undefined), advisors: [] };
+            this.entries.set(name, entry);
+        }
+        entry.advisors.push(advisor);
+        let removed = false;
+        return () => {
+            if (removed)
+                return;
+            removed = true;
+            const e = this.entries.get(name);
+            if (!e)
+                return;
+            const idx = e.advisors.indexOf(advisor);
+            if (idx !== -1)
+                e.advisors.splice(idx, 1);
+        };
     }
     /**
-     * Call a named handler. Returns undefined if no handler is registered.
+     * Call a named handler. Builds the advisor chain on each call:
+     * outermost advisor wraps the next, down to the base handler.
+     * Returns undefined if no handler is registered.
      */
     call(name, ...args) {
-        const fn = this.handlers.get(name);
-        return fn?.(...args);
+        const entry = this.entries.get(name);
+        if (!entry)
+            return undefined;
+        // Build chain: base ← advisor[0] ← advisor[1] ← ... ← advisor[n-1]
+        let fn = entry.base;
+        for (const advisor of entry.advisors) {
+            const next = fn;
+            fn = (...a) => advisor(next, ...a);
+        }
+        return fn(...args);
     }
     /**
      * Check if a named handler exists.
      */
     has(name) {
-        return this.handlers.has(name);
+        return this.entries.has(name);
     }
 }

package/dist/utils/line-editor.d.ts

@@ -2,8 +2,14 @@
  * Minimal line editor with readline-style keybindings.
  *
  * Pure logic — no I/O, no rendering, no event bus. Consumers feed raw
- * terminal input bytes and receive high-level actions back. Buffer and
- * cursor state are public for rendering.
+ * terminal input bytes and receive high-level actions back.
+ *
+ * The internal buffer may contain PUA placeholder characters for pasted
+ * multi-line content. Consumers should use the typed accessors:
+ *   - `text`          — resolved content (pastes expanded), for submit/history/logic
+ *   - `displayText`   — display content (pastes collapsed to labels), for rendering
+ *   - `displayCursor` — cursor column in display coordinates
+ *   - `setText()`     — replace buffer content (clears paste attachments)
  */
 export type LineEditAction = {
     action: "changed";
@@ -24,9 +30,26 @@ export type LineEditAction = {
     action: "arrow-down";
 };
 export declare class LineEditor {
-    buffer: string;
+    private _buf;
     cursor: number;
     private pendingSeq;
+    private inPaste;
+    private pasteAccum;
+    private pastes;
+    private pasteCounter;
+    private history;
+    private historyIndex;
+    private savedBuffer;
+    /** Resolved text — paste placeholders expanded. For submit, history, logic. */
+    get text(): string;
+    /** Display text — paste placeholders replaced with labels. For rendering. */
+    get displayText(): string;
+    /** Cursor position mapped to display-text coordinates. */
+    get displayCursor(): number;
+    /** Number of logical positions in the buffer. */
+    get length(): number;
+    /** Replace buffer content. Clears paste attachments. */
+    setText(value: string): void;
     /** Process raw terminal input, return actions for the consumer. */
     feed(data: string): LineEditAction[];
     /** Check if there's a pending incomplete escape sequence. */
@@ -34,6 +57,12 @@ export declare class LineEditor {
     /** Flush a pending sequence — treat bare \x1b as cancel, discard incomplete CSI. */
     flushPendingEscape(): LineEditAction[];
     clear(): void;
+    /** Add a line to history (most recent first). */
+    pushHistory(line: string): void;
+    /** Navigate to a previous history entry. Returns changed action or null. */
+    historyBack(): LineEditAction | null;
+    /** Navigate to a more recent history entry. Returns changed action or null. */
+    historyForward(): LineEditAction | null;
     private readonly bindings;
     /** Resolve a key name from the bindings table and execute it. */
     private dispatch;

package/dist/utils/line-editor.js

@@ -2,18 +2,93 @@
  * Minimal line editor with readline-style keybindings.
  *
  * Pure logic — no I/O, no rendering, no event bus. Consumers feed raw
- * terminal input bytes and receive high-level actions back. Buffer and
- * cursor state are public for rendering.
+ * terminal input bytes and receive high-level actions back.
+ *
+ * The internal buffer may contain PUA placeholder characters for pasted
+ * multi-line content. Consumers should use the typed accessors:
+ *   - `text`          — resolved content (pastes expanded), for submit/history/logic
+ *   - `displayText`   — display content (pastes collapsed to labels), for rendering
+ *   - `displayCursor` — cursor column in display coordinates
+ *   - `setText()`     — replace buffer content (clears paste attachments)
  */
 // ── Kitty protocol keycode → readable name ──────────────────────
 const KITTY_KEY_NAMES = {
     9: "tab", 13: "enter", 27: "escape", 127: "backspace",
 };
+// ── Paste placeholder ───────────────────────────────────────────
+/** First Unicode Private Use Area codepoint, used as paste placeholder. */
+const PUA_BASE = 0xE000;
+function isPUA(ch) {
+    const code = ch.charCodeAt(0);
+    return code >= PUA_BASE && code <= 0xF8FF;
+}
 // ── Line editor ─────────────────────────────────────────────────
 export class LineEditor {
-    buffer = "";
+    _buf = "";
     cursor = 0;
     pendingSeq = ""; // buffered incomplete escape sequence
+    // ── Bracket paste state ─────────────────────────────────────
+    inPaste = false;
+    pasteAccum = ""; // accumulates during bracket paste
+    pastes = new Map(); // id → pasted content
+    pasteCounter = 0;
+    // ── History ──────────────────────────────────────────────────
+    history = [];
+    historyIndex = -1; // -1 = current input, 0..N = history entries (newest first)
+    savedBuffer = ""; // saves current input when browsing history
+    // ── Public accessors ────────────────────────────────────────
+    /** Resolved text — paste placeholders expanded. For submit, history, logic. */
+    get text() {
+        let result = "";
+        for (const ch of this._buf) {
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            result += paste ?? ch;
+        }
+        return result;
+    }
+    /** Display text — paste placeholders replaced with labels. For rendering. */
+    get displayText() {
+        let result = "";
+        for (const ch of this._buf) {
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            if (paste) {
+                const n = paste.split("\n").length;
+                result += `[paste +${n} lines]`;
+            }
+            else {
+                result += ch;
+            }
+        }
+        return result;
+    }
+    /** Cursor position mapped to display-text coordinates. */
+    get displayCursor() {
+        let pos = 0;
+        for (let i = 0; i < this._buf.length && i < this.cursor; i++) {
+            const ch = this._buf[i];
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            if (paste) {
+                const n = paste.split("\n").length;
+                pos += `[paste +${n} lines]`.length;
+            }
+            else {
+                pos++;
+            }
+        }
+        return pos;
+    }
+    /** Number of logical positions in the buffer. */
+    get length() {
+        return this._buf.length;
+    }
+    /** Replace buffer content. Clears paste attachments. */
+    setText(value) {
+        this._buf = value;
+        this.pastes.clear();
+        this.pasteCounter = 0;
+        this.cursor = value.length;
+    }
+    // ── Input processing ────────────────────────────────────────
     /** Process raw terminal input, return actions for the consumer. */
     feed(data) {
         // If we had a pending incomplete escape sequence, prepend it
@@ -64,7 +139,7 @@ export class LineEditor {
                             actions.push({ action: "arrow-down" });
                             break;
                         case "C":
-                            if (this.cursor < this.buffer.length) {
+                            if (this.cursor < this._buf.length) {
                                 this.cursor++;
                                 actions.push({ action: "changed" });
                             }
@@ -82,8 +157,8 @@ export class LineEditor {
                             }
                             break;
                         case "F": // End
-                            if (this.cursor < this.buffer.length) {
-                                this.cursor = this.buffer.length;
+                            if (this.cursor < this._buf.length) {
+                                this.cursor = this._buf.length;
                                 actions.push({ action: "changed" });
                             }
                             break;
@@ -115,6 +190,16 @@ export class LineEditor {
                 // Other Alt+key — ignore
                 continue;
             }
+            // ── Bracket paste: accumulate into side buffer ─────
+            if (this.inPaste) {
+                if (ch === "\r") {
+                    i++;
+                    continue;
+                } // skip CR (CR+LF → just LF)
+                this.pasteAccum += ch;
+                i++;
+                continue;
+            }
             // ── Control characters ──────────────────────────────
             if (ch.charCodeAt(0) < 0x20 || ch === "\x7f") {
                 const action = this.handleControl(ch);
@@ -124,7 +209,7 @@ export class LineEditor {
                 continue;
             }
             // ── Printable character ─────────────────────────────
-            this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+            this._buf = this._buf.slice(0, this.cursor) + ch + this._buf.slice(this.cursor);
             this.cursor++;
             actions.push({ action: "changed" });
             i++;
@@ -144,9 +229,51 @@ export class LineEditor {
         return wasBarEscape ? [{ action: "cancel" }] : [];
     }
     clear() {
-        this.buffer = "";
+        this._buf = "";
         this.cursor = 0;
         this.pendingSeq = "";
+        this.inPaste = false;
+        this.pasteAccum = "";
+        this.pastes.clear();
+        this.pasteCounter = 0;
+        this.historyIndex = -1;
+        this.savedBuffer = "";
+    }
+    /** Add a line to history (most recent first). */
+    pushHistory(line) {
+        if (!line.trim())
+            return;
+        // Deduplicate: remove if already at top
+        if (this.history.length > 0 && this.history[0] === line)
+            return;
+        this.history.unshift(line);
+        // Cap history size
+        if (this.history.length > 100)
+            this.history.pop();
+    }
+    /** Navigate to a previous history entry. Returns changed action or null. */
+    historyBack() {
+        if (this.historyIndex + 1 >= this.history.length)
+            return null;
+        if (this.historyIndex === -1) {
+            this.savedBuffer = this.text; // save resolved current input
+        }
+        this.historyIndex++;
+        this.setText(this.history[this.historyIndex]);
+        return { action: "changed" };
+    }
+    /** Navigate to a more recent history entry. Returns changed action or null. */
+    historyForward() {
+        if (this.historyIndex <= -1)
+            return null;
+        this.historyIndex--;
+        if (this.historyIndex === -1) {
+            this.setText(this.savedBuffer);
+        }
+        else {
+            this.setText(this.history[this.historyIndex]);
+        }
+        return { action: "changed" };
     }
     // ── Key bindings ────────────────────────────────────────────
     //
@@ -154,17 +281,17 @@ export class LineEditor {
     // characters and kitty protocol sequences resolve to a key name
     // and look it up here. To add a binding, add one entry.
     bindings = {
-        "enter": () => ({ action: "submit", buffer: this.buffer }),
+        "enter": () => ({ action: "submit", buffer: this.text }),
         "ctrl+c": () => ({ action: "cancel" }),
         "tab": () => ({ action: "tab" }),
         "backspace": () => this.deleteBackward(),
-        "ctrl+d": () => this.buffer.length === 0 ? { action: "delete-empty" } : this.deleteForward(),
+        "ctrl+d": () => this._buf.length === 0 ? { action: "delete-empty" } : this.deleteForward(),
         "ctrl+a": () => this.moveTo(0),
-        "ctrl+e": () => this.moveTo(this.buffer.length),
+        "ctrl+e": () => this.moveTo(this._buf.length),
         "ctrl+b": () => this.moveTo(this.cursor - 1),
         "ctrl+f": () => this.moveTo(this.cursor + 1),
         "ctrl+u": () => this.deleteRange(0, this.cursor),
-        "ctrl+k": () => this.deleteRange(this.cursor, this.buffer.length),
+        "ctrl+k": () => this.deleteRange(this.cursor, this._buf.length),
         "ctrl+w": () => this.deleteWordBackward() ? { action: "changed" } : null,
         "alt+f": () => this.wordForward() ? { action: "changed" } : null,
         "alt+b": () => this.wordBackward() ? { action: "changed" } : null,
@@ -215,36 +342,51 @@ export class LineEditor {
     }
     // ── Editing primitives ─────────────────────────────────────
     insertAt(ch) {
-        this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+        this._buf = this._buf.slice(0, this.cursor) + ch + this._buf.slice(this.cursor);
         this.cursor++;
         return { action: "changed" };
     }
     moveTo(pos) {
-        const clamped = Math.max(0, Math.min(pos, this.buffer.length));
+        const clamped = Math.max(0, Math.min(pos, this._buf.length));
         if (clamped === this.cursor)
             return null;
         this.cursor = clamped;
         return { action: "changed" };
     }
     deleteBackward() {
-        if (this.buffer.length === 0)
+        if (this._buf.length === 0)
             return { action: "delete-empty" };
         if (this.cursor <= 0)
             return null;
-        this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+        // If deleting a paste placeholder, also remove the paste entry
+        const deleted = this._buf[this.cursor - 1];
+        if (isPUA(deleted)) {
+            this.pastes.delete(deleted.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, this.cursor - 1) + this._buf.slice(this.cursor);
         this.cursor--;
         return { action: "changed" };
     }
     deleteForward() {
-        if (this.cursor >= this.buffer.length)
+        if (this.cursor >= this._buf.length)
             return null;
-        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+        const deleted = this._buf[this.cursor];
+        if (isPUA(deleted)) {
+            this.pastes.delete(deleted.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, this.cursor) + this._buf.slice(this.cursor + 1);
         return { action: "changed" };
     }
     deleteRange(start, end) {
         if (start >= end)
             return null;
-        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(end);
+        // Clean up any paste entries in the deleted range
+        for (let k = start; k < end; k++) {
+            const ch = this._buf[k];
+            if (isPUA(ch))
+                this.pastes.delete(ch.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, start) + this._buf.slice(end);
         this.cursor = start;
         return { action: "changed" };
     }
@@ -282,7 +424,7 @@ export class LineEditor {
                         actions.push({ action: "changed" });
                 }
                 else {
-                    if (this.cursor < this.buffer.length) {
+                    if (this.cursor < this._buf.length) {
                         this.cursor++;
                         actions.push({ action: "changed" });
                     }
@@ -307,8 +449,8 @@ export class LineEditor {
                 }
                 break;
             case "F": // End
-                if (this.cursor < this.buffer.length) {
-                    this.cursor = this.buffer.length;
+                if (this.cursor < this._buf.length) {
+                    this.cursor = this._buf.length;
                     actions.push({ action: "changed" });
                 }
                 break;
@@ -321,11 +463,39 @@ export class LineEditor {
                     actions.push(action);
                 break;
             }
-            case "~": // Extended keys: Delete (3~), etc.
+            case "~": // Extended keys: Delete (3~), bracket paste (200~/201~), etc.
                 if (params === "3") {
                     // Delete key: delete char under cursor
-                    if (this.cursor < this.buffer.length) {
-                        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+                    if (this.cursor < this._buf.length) {
+                        const deleted = this._buf[this.cursor];
+                        if (isPUA(deleted))
+                            this.pastes.delete(deleted.charCodeAt(0) - PUA_BASE);
+                        this._buf = this._buf.slice(0, this.cursor) + this._buf.slice(this.cursor + 1);
+                        actions.push({ action: "changed" });
+                    }
+                }
+                else if (params === "200") {
+                    this.inPaste = true;
+                    this.pasteAccum = "";
+                }
+                else if (params === "201") {
+                    this.inPaste = false;
+                    if (this.pasteAccum) {
+                        const lines = this.pasteAccum.split("\n");
+                        if (lines.length <= 1) {
+                            // Single-line paste — inline directly
+                            this._buf = this._buf.slice(0, this.cursor) + this.pasteAccum + this._buf.slice(this.cursor);
+                            this.cursor += this.pasteAccum.length;
+                        }
+                        else {
+                            // Multi-line paste — store and insert placeholder
+                            const id = this.pasteCounter++;
+                            this.pastes.set(id, this.pasteAccum);
+                            const placeholder = String.fromCharCode(PUA_BASE + id);
+                            this._buf = this._buf.slice(0, this.cursor) + placeholder + this._buf.slice(this.cursor);
+                            this.cursor++;
+                        }
+                        this.pasteAccum = "";
                         actions.push({ action: "changed" });
                     }
                 }
@@ -339,11 +509,11 @@ export class LineEditor {
         if (this.cursor === 0)
             return false;
         let pos = this.cursor;
-        // Skip spaces
-        while (pos > 0 && this.buffer[pos - 1] === " ")
+        // Skip PUA placeholders and spaces
+        while (pos > 0 && (this._buf[pos - 1] === " " || isPUA(this._buf[pos - 1])))
             pos--;
         // Skip word chars
-        while (pos > 0 && this.buffer[pos - 1] !== " ")
+        while (pos > 0 && this._buf[pos - 1] !== " " && !isPUA(this._buf[pos - 1]))
             pos--;
         if (pos === this.cursor)
             return false;
@@ -351,14 +521,14 @@ export class LineEditor {
         return true;
     }
     wordForward() {
-        if (this.cursor >= this.buffer.length)
+        if (this.cursor >= this._buf.length)
             return false;
         let pos = this.cursor;
-        // Skip word chars
-        while (pos < this.buffer.length && this.buffer[pos] !== " ")
+        // Skip word chars and PUA placeholders
+        while (pos < this._buf.length && this._buf[pos] !== " " && !isPUA(this._buf[pos]))
             pos++;
-        // Skip spaces
-        while (pos < this.buffer.length && this.buffer[pos] === " ")
+        // Skip spaces and PUA
+        while (pos < this._buf.length && (this._buf[pos] === " " || isPUA(this._buf[pos])))
             pos++;
         if (pos === this.cursor)
             return false;
@@ -370,15 +540,27 @@ export class LineEditor {
             return false;
         const start = this.cursor;
         this.wordBackward();
-        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(start);
+        // Clean up paste entries
+        for (let k = this.cursor; k < start; k++) {
+            const ch = this._buf[k];
+            if (isPUA(ch))
+                this.pastes.delete(ch.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, this.cursor) + this._buf.slice(start);
         return true;
     }
     deleteWordForward() {
-        if (this.cursor >= this.buffer.length)
+        if (this.cursor >= this._buf.length)
             return false;
         const start = this.cursor;
         this.wordForward();
-        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(this.cursor);
+        // Clean up paste entries
+        for (let k = start; k < this.cursor; k++) {
+            const ch = this._buf[k];
+            if (isPUA(ch))
+                this.pastes.delete(ch.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, start) + this._buf.slice(this.cursor);
         this.cursor = start;
         return true;
     }

package/dist/utils/markdown.d.ts

@@ -1,3 +1,4 @@
+export declare const MAX_CONTENT_WIDTH = 90;
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.

package/dist/utils/markdown.js

@@ -1,6 +1,6 @@
-import { visibleLen } from "./ansi.js";
+import { visibleLen, truncateToWidth, padEndToWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
-const MAX_CONTENT_WIDTH = 90;
+export const MAX_CONTENT_WIDTH = 90;
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.
@@ -177,7 +177,7 @@ export class MarkdownRenderer {
         const colWidths = new Array(numCols).fill(0);
         for (const row of dataRows) {
             for (let c = 0; c < numCols; c++) {
-                colWidths[c] = Math.max(colWidths[c], row[c].length);
+                colWidths[c] = Math.max(colWidths[c], visibleLen(row[c]));
             }
         }
         // Shrink columns proportionally if total exceeds content width
@@ -201,7 +201,7 @@ export class MarkdownRenderer {
             const isHeader = hasHeader && i === 0;
             const cells = row.map((cell, c) => {
                 const w = colWidths[c];
-                const text = cell.length > w ? cell.slice(0, w - 1) + "…" : cell.padEnd(w);
+                const text = visibleLen(cell) > w ? truncateToWidth(cell, w) : padEndToWidth(cell, w);
                 return isHeader ? `${p.bold}${text}${p.reset}` : text;
             });
             this.writeLine(`${p.dim}│${p.reset} ${cells.join(` ${p.dim}│${p.reset} `)} ${p.dim}│${p.reset}`);

package/dist/utils/message-utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Utilities for manipulating OpenAI-format message arrays.
+ *
+ * Used by extensions advising `conversation:prepare` to transform
+ * the message array before it's sent to the LLM.
+ */
+/**
+ * Find tool call IDs matching a tool name and optional argument filter.
+ *
+ * Scans assistant messages for tool_calls where `function.name` matches
+ * and parsed arguments satisfy the filter (shallow key/value match).
+ *
+ * Returns call IDs in message order (earliest first).
+ */
+export declare function findToolCallIds(messages: any[], toolName: string, argFilter?: Record<string, unknown>): string[];
+/**
+ * Replace tool result content for specific call IDs.
+ *
+ * Returns a new array (shallow copy) with matching tool messages
+ * replaced. Non-matching messages are passed through by reference.
+ */
+export declare function stubToolResults(messages: any[], callIds: Set<string>, stub: string): any[];
+/**
+ * Deduplicate tool results: keep only the latest result for a given
+ * tool name + argument filter, replace all older results with a stub.
+ *
+ * Common use case: a file that's read repeatedly (e.g. a live transcript)
+ * — only the most recent read matters.
+ *
+ * Example:
+ *   dedupeToolResults(messages, "read_file",
+ *     { path: "/path/to/transcript.txt" },
+ *     "[stale — superseded by later read]")
+ */
+export declare function dedupeToolResults(messages: any[], toolName: string, argFilter?: Record<string, unknown>, stub?: string): any[];