@agentionai/agents 0.10.0 → 0.10.2

package/dist/agents/anthropic/ClaudeAgent.js

@@ -81,6 +81,12 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         else {
             this.addMessageToHistory("user", input);
         }
+        // Mark session boundary so transform plugins (e.g. toolResultMaskingPlugin)
+        // don't mask tool results produced within this execute() loop.
+        this.history.setSessionAnchor();
+        // Suspend auto-trimming so tool_use / tool_result pairs are never split
+        // mid-loop. endExecution() in the finally block enforces limits once.
+        this.history.beginExecution();
         try {
             const messages = transformers_1.anthropicTransformer.toProvider(this.history.getEntries());
             const systemMessage = this.history.getSystemMessage();
@@ -122,6 +128,9 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 throw executionError;
             }
         }
+        finally {
+            this.history.endExecution();
+        }
     }
     async handleResponse(response) {
         const usage = this.parseUsage(response.usage);

package/dist/agents/google/GeminiAgent.js

@@ -181,6 +181,12 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
         else {
             this.addMessageToHistory("user", input);
         }
+        // Mark session boundary so transform plugins (e.g. toolResultMaskingPlugin)
+        // don't mask tool results produced within this execute() loop.
+        this.history.setSessionAnchor();
+        // Suspend auto-trimming so tool_use / tool_result pairs are never split
+        // mid-loop. endExecution() in the finally block enforces limits once.
+        this.history.beginExecution();
         try {
             const contents = transformers_1.geminiTransformer.toProvider(this.history.getEntries());
             const systemMessage = this.history.getSystemMessage();
@@ -226,6 +232,9 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                 throw executionError;
             }
         }
+        finally {
+            this.history.endExecution();
+        }
     }
     async handleResponse(response) {
         const result = response.response;

package/dist/agents/mistral/MistralAgent.js

@@ -91,6 +91,12 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
         else {
             this.addMessageToHistory("user", input);
         }
+        // Mark session boundary so transform plugins (e.g. toolResultMaskingPlugin)
+        // don't mask tool results produced within this execute() loop.
+        this.history.setSessionAnchor();
+        // Suspend auto-trimming so tool_use / tool_result pairs are never split
+        // mid-loop. endExecution() in the finally block enforces limits once.
+        this.history.beginExecution();
         try {
             const messages = transformers_1.mistralTransformer.toProvider(this.history.getEntries());
             const response = await this.client.chat.complete({
@@ -130,6 +136,9 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                 throw executionError;
             }
         }
+        finally {
+            this.history.endExecution();
+        }
     }
     async handleResponse(response) {
         if (!response.choices || response.choices.length === 0) {

package/dist/agents/openai/OpenAiAgent.js

@@ -102,6 +102,12 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         else {
             this.addMessageToHistory("user", input);
         }
+        // Mark session boundary so transform plugins (e.g. toolResultMaskingPlugin)
+        // don't mask tool results produced within this execute() loop.
+        this.history.setSessionAnchor();
+        // Suspend auto-trimming so tool_use / tool_result pairs are never split
+        // mid-loop. endExecution() in the finally block enforces limits once.
+        this.history.beginExecution();
         try {
             const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.getEntries());
             const response = await this.client.responses.create({
@@ -147,6 +153,9 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 throw executionError;
             }
         }
+        finally {
+            this.history.endExecution();
+        }
     }
     async handleResponse(response) {
         if (!response.output || !response.output.length) {

package/dist/history/History.d.ts

@@ -61,7 +61,7 @@ type EntryWithMetadata = ReducibleEntry;
 /**
  * History configuration options
  */
-type HistoryOptions = {
+export type HistoryOptions = {
     maxLength?: number;
     /**
      * Maximum estimated tokens to retain in history. When exceeded, oldest
@@ -123,6 +123,8 @@ export declare class History extends EventEmitter {
     transient: boolean;
     private _plugins;
     private _reducing;
+    private _executing;
+    private _sessionAnchor;
     constructor(entries?: HistoryEntry[], options?: HistoryOptions);
     /**
      * Register a plugin with this history instance.
@@ -137,6 +139,20 @@ export declare class History extends EventEmitter {
      * ```
      */
     use(plugin: HistoryPlugin): this;
+    /**
+     * Mark the current entry count as the session boundary.
+     * Call this at the start of each agent `execute()` after adding the user
+     * message. Transform plugins (e.g. toolResultMaskingPlugin) will not mask
+     * any entries added at or after this position, preventing tool results from
+     * the current execution loop from being masked mid-session.
+     */
+    setSessionAnchor(): void;
+    /**
+     * The entry index set by the last call to `setSessionAnchor()`, or `null`
+     * if no anchor has been set. Entries at this index or beyond belong to the
+     * current session and should not be masked by transform plugins.
+     */
+    get sessionAnchor(): number | null;
     /**
      * Add a complete history entry
      */
@@ -232,11 +248,40 @@ export declare class History extends EventEmitter {
      * Create a copy of this history
      */
     clone(options?: HistoryOptions): History;
+    /**
+     * Signal the start of an agent execute() loop. While executing, automatic
+     * trimming on addEntry() is suspended so tool_use / tool_result pairs are
+     * never split mid-loop. Call endExecution() in a finally block to resume.
+     */
+    beginExecution(): void;
+    /**
+     * Signal the end of an agent execute() loop. Resumes automatic trimming and
+     * immediately enforces maxLength / maxTokens limits on the accumulated history.
+     */
+    endExecution(): void;
+    /**
+     * Explicitly enforce maxLength and maxTokens limits. Useful when using
+     * History standalone, outside of an agent execute() loop.
+     */
+    trim(): void;
+    /**
+     * Apply maxLength and maxTokens trimming to the current entry list.
+     * Safe to call after bulk-loading entries (e.g. RedisHistory.load()).
+     * Subclasses may call this after directly manipulating _entries.
+     */
+    protected applyTrimming(): void;
     /**
      * Drop oldest non-system entries until totalEstimatedTokens fits within budget.
      * Called synchronously from addEntry() as a safety net.
      * The system message is always preserved.
      */
     private trimToTokenBudget;
+    /**
+     * After any trim, remove tool_result blocks whose paired tool_use was dropped.
+     * Entries that become empty after filtering are also removed.
+     * This prevents 400 errors from providers that require tool_result blocks to
+     * have a corresponding tool_use in the conversation history.
+     */
+    private sanitizeToolPairs;
 }
 //# sourceMappingURL=History.d.ts.map

package/dist/history/History.js

@@ -127,6 +127,8 @@ class History extends events_1.default {
         this.transient = false;
         this._plugins = [];
         this._reducing = false;
+        this._executing = false;
+        this._sessionAnchor = null;
         this.options = options;
         this.transient = Boolean(options?.transient);
         // Convert initial entries to internal format with metadata
@@ -154,6 +156,24 @@ class History extends events_1.default {
         plugin.onRegistered?.(this);
         return this;
     }
+    /**
+     * Mark the current entry count as the session boundary.
+     * Call this at the start of each agent `execute()` after adding the user
+     * message. Transform plugins (e.g. toolResultMaskingPlugin) will not mask
+     * any entries added at or after this position, preventing tool results from
+     * the current execution loop from being masked mid-session.
+     */
+    setSessionAnchor() {
+        this._sessionAnchor = this._entries.length;
+    }
+    /**
+     * The entry index set by the last call to `setSessionAnchor()`, or `null`
+     * if no anchor has been set. Entries at this index or beyond belong to the
+     * current session and should not be masked by transform plugins.
+     */
+    get sessionAnchor() {
+        return this._sessionAnchor;
+    }
     // ===========================================================================
     // Core write operations
     // ===========================================================================
@@ -172,12 +192,7 @@ class History extends events_1.default {
             ...entry,
             __metadata,
         });
-        if (this.options.maxLength && this._entries.length > this.options.maxLength) {
-            this._entries = this._entries.slice(this._entries.length - this.options.maxLength);
-        }
-        if (this.options.maxTokens) {
-            this.trimToTokenBudget();
-        }
+        this.applyTrimming();
         this.emit("entry", entry);
         // Fire plugin afterAdd hooks. Skipped during reduce() to avoid recursion
         // when compression plugins add summary entries to the history.
@@ -385,6 +400,45 @@ class History extends events_1.default {
     // ===========================================================================
     // Private helpers
     // ===========================================================================
+    /**
+     * Signal the start of an agent execute() loop. While executing, automatic
+     * trimming on addEntry() is suspended so tool_use / tool_result pairs are
+     * never split mid-loop. Call endExecution() in a finally block to resume.
+     */
+    beginExecution() {
+        this._executing = true;
+    }
+    /**
+     * Signal the end of an agent execute() loop. Resumes automatic trimming and
+     * immediately enforces maxLength / maxTokens limits on the accumulated history.
+     */
+    endExecution() {
+        this._executing = false;
+        this.applyTrimming();
+    }
+    /**
+     * Explicitly enforce maxLength and maxTokens limits. Useful when using
+     * History standalone, outside of an agent execute() loop.
+     */
+    trim() {
+        this.applyTrimming();
+    }
+    /**
+     * Apply maxLength and maxTokens trimming to the current entry list.
+     * Safe to call after bulk-loading entries (e.g. RedisHistory.load()).
+     * Subclasses may call this after directly manipulating _entries.
+     */
+    applyTrimming() {
+        if (this._executing)
+            return;
+        if (this.options.maxLength && this._entries.length > this.options.maxLength) {
+            this._entries = this._entries.slice(this._entries.length - this.options.maxLength);
+            this.sanitizeToolPairs();
+        }
+        if (this.options.maxTokens) {
+            this.trimToTokenBudget();
+        }
+    }
     /**
      * Drop oldest non-system entries until totalEstimatedTokens fits within budget.
      * Called synchronously from addEntry() as a safety net.
@@ -400,6 +454,32 @@ class History extends events_1.default {
                 break;
             this._entries.splice(firstNonSystem, 1);
         }
+        this.sanitizeToolPairs();
+    }
+    /**
+     * After any trim, remove tool_result blocks whose paired tool_use was dropped.
+     * Entries that become empty after filtering are also removed.
+     * This prevents 400 errors from providers that require tool_result blocks to
+     * have a corresponding tool_use in the conversation history.
+     */
+    sanitizeToolPairs() {
+        // Collect all tool_use IDs still present in the history
+        const toolUseIds = new Set();
+        for (const entry of this._entries) {
+            for (const block of entry.content) {
+                if ((0, types_1.isToolUseContent)(block)) {
+                    toolUseIds.add(block.id);
+                }
+            }
+        }
+        // Filter out orphaned tool_result blocks; drop entries that become empty
+        this._entries = this._entries.filter((entry) => {
+            const filtered = entry.content.filter((block) => !(0, types_1.isToolResultContent)(block) || toolUseIds.has(block.tool_use_id));
+            if (filtered.length === 0)
+                return false;
+            entry.content = filtered;
+            return true;
+        });
     }
 }
 exports.History = History;

package/dist/history/RedisHistory.d.ts

@@ -1,13 +1,15 @@
-import { History } from "./History";
+import { History, HistoryOptions } from "./History";
 interface RedisInstance {
     get(key: string): Promise<string | null>;
     set(key: string, content: string): Promise<"OK">;
 }
 export declare class RedisHistory extends History {
     private redisInstance;
-    constructor(redisInstance: RedisInstance);
+    constructor(redisInstance: RedisInstance, options?: HistoryOptions);
     /**
-     * Loads history entries from Redis using the specified key
+     * Loads history entries from Redis using the specified key.
+     * Entries are re-added via addEntry() so metadata is computed correctly.
+     * Trimming (maxLength / maxTokens) is applied after load.
      *
      * @param {string} key - The Redis key to retrieve history entries from
      * @returns {Promise<void>} A promise that resolves when history is loaded

package/dist/history/RedisHistory.js

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisHistory = void 0;
 const History_1 = require("./History");
 class RedisHistory extends History_1.History {
-    constructor(redisInstance) {
-        super([], { transient: false });
+    constructor(redisInstance, options = {}) {
+        super([], options);
         this.redisInstance = redisInstance;
     }
     /**
-     * Loads history entries from Redis using the specified key
+     * Loads history entries from Redis using the specified key.
+     * Entries are re-added via addEntry() so metadata is computed correctly.
+     * Trimming (maxLength / maxTokens) is applied after load.
      *
      * @param {string} key - The Redis key to retrieve history entries from
      * @returns {Promise<void>} A promise that resolves when history is loaded
@@ -16,15 +18,26 @@ class RedisHistory extends History_1.History {
      */
     async load(key) {
         try {
-            // Retrieve the serialized history from Redis
             const serializedHistory = await this.redisInstance.get(key);
-            // If no history exists for the key, return early
-            if (!serializedHistory) {
+            if (!serializedHistory)
                 return;
-            }
-            // Parse the serialized history and create a new History instance
             const entries = JSON.parse(serializedHistory);
-            this._entries = entries;
+            this._entries = [];
+            // Re-add via addEntry to compute metadata; suppress plugins during bulk load
+            // by temporarily bypassing plugin afterAdd hooks (handled by _reducing flag
+            // which is private — so we push entries directly and call applyTrimming once).
+            for (const entry of entries) {
+                const serialized = JSON.stringify(entry.content);
+                this._entries.push({
+                    ...entry,
+                    __metadata: {
+                        date: new Date().toISOString(),
+                        contentLength: serialized.length,
+                        estimatedTokens: Math.ceil(serialized.length / 4),
+                    },
+                });
+            }
+            this.applyTrimming();
         }
         catch (error) {
             console.error(`Error loading history from Redis key "${key}":`, error);
@@ -40,9 +53,7 @@ class RedisHistory extends History_1.History {
      */
     async save(key) {
         try {
-            // Serialize the current history entries
             const serializedHistory = this.toJSON();
-            // Save the serialized history to Redis
             await this.redisInstance.set(key, serializedHistory);
         }
         catch (error) {

package/dist/history/plugins/toolResultMaskingPlugin.js

@@ -88,7 +88,13 @@ function toolResultMaskingPlugin(options) {
                 }
             }
             const maskable = [];
+            const sessionAnchor = _history?.sessionAnchor ?? null;
             for (let ei = 0; ei < entries.length; ei++) {
+                // Never mask entries from the current execute() session — doing so
+                // would cause the model to call retrieve_tool_result mid-loop, whose
+                // result would itself be masked, creating an infinite retrieval loop.
+                if (sessionAnchor !== null && ei >= sessionAnchor)
+                    continue;
                 const entry = entries[ei];
                 for (let bi = 0; bi < entry.content.length; bi++) {
                     const block = entry.content[bi];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",