@illuma-ai/agents 1.0.89 → 1.0.93

package/src/agents/__tests__/AgentContext.test.js

@@ -0,0 +1,678 @@
+// src/agents/__tests__/AgentContext.test.ts
+import { AgentContext } from '../AgentContext';
+import { Providers } from '@/common';
+describe('AgentContext', () => {
+    const createBasicContext = (options = {}) => {
+        const { agentConfig = {}, tokenCounter, indexTokenCountMap } = options;
+        return AgentContext.fromConfig({
+            agentId: 'test-agent',
+            provider: Providers.OPENAI,
+            instructions: 'Test instructions',
+            ...agentConfig,
+        }, tokenCounter, indexTokenCountMap);
+    };
+    const createMockTool = (name) => ({
+        name,
+        description: `Mock ${name} tool`,
+        invoke: jest.fn(),
+        schema: { type: 'object', properties: {} },
+    });
+    describe('System Runnable - Lazy Creation', () => {
+        it('creates system runnable on first access', () => {
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Hello world' },
+            });
+            expect(ctx.systemRunnable).toBeDefined();
+        });
+        it('returns cached system runnable on subsequent access', () => {
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Hello world' },
+            });
+            const first = ctx.systemRunnable;
+            const second = ctx.systemRunnable;
+            expect(first).toBe(second);
+        });
+        it('returns undefined when no instructions provided', () => {
+            const ctx = createBasicContext({
+                agentConfig: {
+                    instructions: undefined,
+                    additional_instructions: undefined,
+                },
+            });
+            expect(ctx.systemRunnable).toBeUndefined();
+        });
+        it('includes additional_instructions in system message', () => {
+            const ctx = createBasicContext({
+                agentConfig: {
+                    instructions: 'Base instructions',
+                    additional_instructions: 'Additional instructions',
+                },
+            });
+            expect(ctx.systemRunnable).toBeDefined();
+        });
+    });
+    describe('System Runnable - Stale Flag', () => {
+        it('rebuilds when marked stale via markToolsAsDiscovered', () => {
+            const toolRegistry = new Map([
+                [
+                    'deferred_tool',
+                    {
+                        name: 'deferred_tool',
+                        description: 'A deferred code-only tool',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: true,
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Test', toolRegistry },
+            });
+            const firstRunnable = ctx.systemRunnable;
+            const hasNew = ctx.markToolsAsDiscovered(['deferred_tool']);
+            expect(hasNew).toBe(true);
+            const secondRunnable = ctx.systemRunnable;
+            expect(secondRunnable).not.toBe(firstRunnable);
+        });
+        it('does not rebuild when discovering already-known tools', () => {
+            const toolRegistry = new Map([
+                [
+                    'tool1',
+                    {
+                        name: 'tool1',
+                        description: 'Tool 1',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: true,
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Test', toolRegistry },
+            });
+            ctx.markToolsAsDiscovered(['tool1']);
+            const firstRunnable = ctx.systemRunnable;
+            const hasNew = ctx.markToolsAsDiscovered(['tool1']);
+            expect(hasNew).toBe(false);
+            const secondRunnable = ctx.systemRunnable;
+            expect(secondRunnable).toBe(firstRunnable);
+        });
+    });
+    describe('markToolsAsDiscovered', () => {
+        it('returns true when new tools are discovered', () => {
+            const ctx = createBasicContext();
+            const result = ctx.markToolsAsDiscovered(['tool1', 'tool2']);
+            expect(result).toBe(true);
+            expect(ctx.discoveredToolNames.has('tool1')).toBe(true);
+            expect(ctx.discoveredToolNames.has('tool2')).toBe(true);
+        });
+        it('returns false when all tools already discovered', () => {
+            const ctx = createBasicContext();
+            ctx.markToolsAsDiscovered(['tool1']);
+            const result = ctx.markToolsAsDiscovered(['tool1']);
+            expect(result).toBe(false);
+        });
+        it('returns true if at least one tool is new', () => {
+            const ctx = createBasicContext();
+            ctx.markToolsAsDiscovered(['tool1']);
+            const result = ctx.markToolsAsDiscovered(['tool1', 'tool2']);
+            expect(result).toBe(true);
+            expect(ctx.discoveredToolNames.size).toBe(2);
+        });
+        it('handles empty array gracefully', () => {
+            const ctx = createBasicContext();
+            const result = ctx.markToolsAsDiscovered([]);
+            expect(result).toBe(false);
+        });
+    });
+    describe('buildProgrammaticOnlyToolsInstructions', () => {
+        it('includes code_execution-only tools in system message', () => {
+            const toolRegistry = new Map([
+                [
+                    'programmatic_tool',
+                    {
+                        name: 'programmatic_tool',
+                        description: 'Only callable via code execution',
+                        allowed_callers: ['code_execution'],
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Base', toolRegistry },
+            });
+            const runnable = ctx.systemRunnable;
+            expect(runnable).toBeDefined();
+        });
+        it('excludes direct-callable tools from programmatic section', () => {
+            const toolRegistry = new Map([
+                [
+                    'direct_tool',
+                    {
+                        name: 'direct_tool',
+                        description: 'Direct callable',
+                        allowed_callers: ['direct'],
+                    },
+                ],
+                [
+                    'both_tool',
+                    {
+                        name: 'both_tool',
+                        description: 'Both direct and code',
+                        allowed_callers: ['direct', 'code_execution'],
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Base', toolRegistry },
+            });
+            expect(ctx.systemRunnable).toBeDefined();
+        });
+        it('excludes deferred code_execution-only tools until discovered', () => {
+            const toolRegistry = new Map([
+                [
+                    'deferred_code_tool',
+                    {
+                        name: 'deferred_code_tool',
+                        description: 'Deferred and code-only',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: true,
+                    },
+                ],
+                [
+                    'immediate_code_tool',
+                    {
+                        name: 'immediate_code_tool',
+                        description: 'Immediate and code-only',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: false,
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Base', toolRegistry },
+            });
+            const firstRunnable = ctx.systemRunnable;
+            expect(firstRunnable).toBeDefined();
+            ctx.markToolsAsDiscovered(['deferred_code_tool']);
+            const secondRunnable = ctx.systemRunnable;
+            expect(secondRunnable).not.toBe(firstRunnable);
+        });
+    });
+    describe('getToolsForBinding', () => {
+        it('returns all tools when no toolRegistry', () => {
+            const tools = [createMockTool('tool1'), createMockTool('tool2')];
+            const ctx = createBasicContext({ agentConfig: { tools } });
+            const result = ctx.getToolsForBinding();
+            expect(result).toEqual(tools);
+        });
+        it('excludes code_execution-only tools', () => {
+            const tools = [
+                createMockTool('direct_tool'),
+                createMockTool('code_only_tool'),
+            ];
+            const toolRegistry = new Map([
+                ['direct_tool', { name: 'direct_tool', allowed_callers: ['direct'] }],
+                [
+                    'code_only_tool',
+                    { name: 'code_only_tool', allowed_callers: ['code_execution'] },
+                ],
+            ]);
+            const ctx = createBasicContext({ agentConfig: { tools, toolRegistry } });
+            const result = ctx.getToolsForBinding();
+            expect(result?.length).toBe(1);
+            expect((result?.[0]).name).toBe('direct_tool');
+        });
+        it('excludes deferred tools until discovered', () => {
+            const tools = [
+                createMockTool('immediate_tool'),
+                createMockTool('deferred_tool'),
+            ];
+            const toolRegistry = new Map([
+                [
+                    'immediate_tool',
+                    {
+                        name: 'immediate_tool',
+                        allowed_callers: ['direct'],
+                        defer_loading: false,
+                    },
+                ],
+                [
+                    'deferred_tool',
+                    {
+                        name: 'deferred_tool',
+                        allowed_callers: ['direct'],
+                        defer_loading: true,
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({ agentConfig: { tools, toolRegistry } });
+            let result = ctx.getToolsForBinding();
+            expect(result?.length).toBe(1);
+            expect((result?.[0]).name).toBe('immediate_tool');
+            ctx.markToolsAsDiscovered(['deferred_tool']);
+            result = ctx.getToolsForBinding();
+            expect(result?.length).toBe(2);
+        });
+        it('includes tools with both direct and code_execution callers', () => {
+            const tools = [createMockTool('hybrid_tool')];
+            const toolRegistry = new Map([
+                [
+                    'hybrid_tool',
+                    {
+                        name: 'hybrid_tool',
+                        allowed_callers: ['direct', 'code_execution'],
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({ agentConfig: { tools, toolRegistry } });
+            const result = ctx.getToolsForBinding();
+            expect(result?.length).toBe(1);
+        });
+        it('defaults to direct when allowed_callers not specified', () => {
+            const tools = [createMockTool('default_tool')];
+            const toolRegistry = new Map([
+                ['default_tool', { name: 'default_tool' }],
+            ]);
+            const ctx = createBasicContext({ agentConfig: { tools, toolRegistry } });
+            const result = ctx.getToolsForBinding();
+            expect(result?.length).toBe(1);
+        });
+    });
+    describe('Token Accounting', () => {
+        const mockTokenCounter = (msg) => {
+            const content = typeof msg.content === 'string'
+                ? msg.content
+                : JSON.stringify(msg.content);
+            return content.length;
+        };
+        it('counts system message tokens on first access', () => {
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Hello' },
+                tokenCounter: mockTokenCounter,
+            });
+            ctx.initializeSystemRunnable();
+            expect(ctx.instructionTokens).toBeGreaterThan(0);
+        });
+        it('updates token count when system message changes', () => {
+            const toolRegistry = new Map([
+                [
+                    'code_tool',
+                    {
+                        name: 'code_tool',
+                        description: 'A tool with a long description that adds tokens',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: true,
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Short', toolRegistry },
+                tokenCounter: mockTokenCounter,
+            });
+            ctx.initializeSystemRunnable();
+            const initialTokens = ctx.instructionTokens;
+            ctx.markToolsAsDiscovered(['code_tool']);
+            void ctx.systemRunnable;
+            expect(ctx.instructionTokens).toBeGreaterThan(initialTokens);
+        });
+    });
+    describe('reset()', () => {
+        it('clears all cached state', () => {
+            const ctx = createBasicContext({ agentConfig: { instructions: 'Test' } });
+            ctx.markToolsAsDiscovered(['tool1']);
+            void ctx.systemRunnable;
+            ctx.instructionTokens = 100;
+            ctx.indexTokenCountMap = { '0': 50 };
+            ctx.currentUsage = { input_tokens: 100 };
+            ctx.reset();
+            expect(ctx.discoveredToolNames.size).toBe(0);
+            expect(ctx.instructionTokens).toBe(0);
+            expect(ctx.indexTokenCountMap).toEqual({});
+            expect(ctx.currentUsage).toBeUndefined();
+        });
+        it('rebuilds indexTokenCountMap from base map after reset', async () => {
+            const tokenCounter = jest.fn(() => 5);
+            const ctx = createBasicContext({
+                tokenCounter,
+                indexTokenCountMap: { '0': 10, '1': 20 },
+            });
+            await ctx.tokenCalculationPromise;
+            ctx.indexTokenCountMap = {};
+            ctx.reset();
+            await ctx.tokenCalculationPromise;
+            expect(ctx.indexTokenCountMap['1']).toBe(20);
+            expect(ctx.indexTokenCountMap['0'] ?? 0).toBeGreaterThanOrEqual(10);
+        });
+        it('forces rebuild on next systemRunnable access', () => {
+            const ctx = createBasicContext({ agentConfig: { instructions: 'Test' } });
+            const firstRunnable = ctx.systemRunnable;
+            ctx.reset();
+            ctx.instructions = 'Test';
+            const secondRunnable = ctx.systemRunnable;
+            expect(secondRunnable).not.toBe(firstRunnable);
+        });
+    });
+    describe('initializeSystemRunnable()', () => {
+        it('explicitly initializes system runnable', () => {
+            const ctx = createBasicContext({ agentConfig: { instructions: 'Test' } });
+            expect(ctx['cachedSystemRunnable']).toBeUndefined();
+            ctx.initializeSystemRunnable();
+            expect(ctx['cachedSystemRunnable']).toBeDefined();
+        });
+        it('is idempotent when not stale', () => {
+            const ctx = createBasicContext({ agentConfig: { instructions: 'Test' } });
+            ctx.initializeSystemRunnable();
+            const first = ctx['cachedSystemRunnable'];
+            ctx.initializeSystemRunnable();
+            const second = ctx['cachedSystemRunnable'];
+            expect(first).toBe(second);
+        });
+    });
+    describe('Edge Cases', () => {
+        it('handles empty toolRegistry gracefully', () => {
+            const ctx = createBasicContext({
+                agentConfig: {
+                    instructions: 'Test',
+                    toolRegistry: new Map(),
+                    tools: [],
+                },
+            });
+            expect(ctx.systemRunnable).toBeDefined();
+            expect(ctx.getToolsForBinding()).toEqual([]);
+        });
+        it('handles undefined tools array', () => {
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Test', tools: undefined },
+            });
+            expect(ctx.getToolsForBinding()).toBeUndefined();
+        });
+        it('handles tool not in registry', () => {
+            const tools = [createMockTool('unknown_tool')];
+            const toolRegistry = new Map();
+            const ctx = createBasicContext({ agentConfig: { tools, toolRegistry } });
+            const result = ctx.getToolsForBinding();
+            expect(result?.length).toBe(1);
+        });
+        it('handles tool without name property', () => {
+            const toolWithoutName = { invoke: jest.fn() };
+            const toolRegistry = new Map();
+            const ctx = createBasicContext({
+                agentConfig: { tools: [toolWithoutName], toolRegistry },
+            });
+            const result = ctx.getToolsForBinding();
+            expect(result?.length).toBe(1);
+        });
+        it('handles discovery of non-existent tool', () => {
+            const toolRegistry = new Map([
+                [
+                    'real_tool',
+                    { name: 'real_tool', allowed_callers: ['code_execution'] },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Test', toolRegistry },
+            });
+            const result = ctx.markToolsAsDiscovered(['fake_tool']);
+            expect(result).toBe(true);
+            expect(ctx.discoveredToolNames.has('fake_tool')).toBe(true);
+        });
+    });
+    describe('Multi-Step Run Flow (emulating createCallModel)', () => {
+        /**
+         * This test emulates the flow in Graph.createCallModel across multiple turns:
+         *
+         * Turn 1: User asks a question
+         *   - No tool search results yet
+         *   - System runnable built with initial instructions
+         *   - Token map initialized
+         *
+         * Turn 2: Tool results come back (including tool search)
+         *   - extractToolDiscoveries() finds new tools
+         *   - markToolsAsDiscovered() called → sets stale flag
+         *   - systemRunnable getter rebuilds with discovered tools
+         *   - Token counts updated
+         *
+         * Turn 3: Another turn with same discovered tools
+         *   - No new discoveries
+         *   - systemRunnable returns cached (not rebuilt)
+         *   - Token counts unchanged
+         */
+        const mockTokenCounter = (msg) => {
+            const content = typeof msg.content === 'string'
+                ? msg.content
+                : JSON.stringify(msg.content);
+            return Math.ceil(content.length / 4); // ~4 chars per token (realistic)
+        };
+        it('handles complete multi-step run with tool discovery', () => {
+            // Setup: Tools with different configurations
+            const tools = [
+                createMockTool('always_available'),
+                createMockTool('deferred_direct_tool'),
+                createMockTool('deferred_code_tool'),
+            ];
+            const toolRegistry = new Map([
+                [
+                    'always_available',
+                    {
+                        name: 'always_available',
+                        description: 'Always available tool',
+                        allowed_callers: ['direct'],
+                        defer_loading: false,
+                    },
+                ],
+                [
+                    'deferred_direct_tool',
+                    {
+                        name: 'deferred_direct_tool',
+                        description: 'Deferred but direct-callable',
+                        allowed_callers: ['direct'],
+                        defer_loading: true,
+                    },
+                ],
+                [
+                    'deferred_code_tool',
+                    {
+                        name: 'deferred_code_tool',
+                        description: 'Deferred and code-execution only - hidden until discovered',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: true,
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: {
+                    instructions: 'You are a helpful assistant.',
+                    tools,
+                    toolRegistry,
+                },
+                tokenCounter: mockTokenCounter,
+            });
+            // ========== TURN 1: Initial call (like first createCallModel) ==========
+            // In createCallModel, we first check for tool discoveries (none yet)
+            const turn1Discoveries = []; // No tool search results
+            if (turn1Discoveries.length > 0) {
+                ctx.markToolsAsDiscovered(turn1Discoveries);
+            }
+            // Get tools for binding
+            const turn1Tools = ctx.getToolsForBinding();
+            expect(turn1Tools?.length).toBe(1); // Only 'always_available'
+            expect(turn1Tools?.map((t) => t.name)).toEqual([
+                'always_available',
+            ]);
+            // Access system runnable (triggers lazy build)
+            const turn1Runnable = ctx.systemRunnable;
+            expect(turn1Runnable).toBeDefined();
+            // Store initial token count
+            const turn1Tokens = ctx.instructionTokens;
+            expect(turn1Tokens).toBeGreaterThan(0);
+            // Simulate token map update (as done in fromConfig flow)
+            ctx.updateTokenMapWithInstructions({ '0': 10, '1': 20 });
+            expect(ctx.indexTokenCountMap['0']).toBe(10 + turn1Tokens);
+            expect(ctx.indexTokenCountMap['1']).toBe(20);
+            // ========== TURN 2: Tool search results come back ==========
+            // Simulate tool search discovering tools
+            const turn2Discoveries = ['deferred_direct_tool', 'deferred_code_tool'];
+            const hasNewDiscoveries = ctx.markToolsAsDiscovered(turn2Discoveries);
+            expect(hasNewDiscoveries).toBe(true);
+            // Get tools for binding - now includes discovered direct tool
+            const turn2Tools = ctx.getToolsForBinding();
+            expect(turn2Tools?.length).toBe(2); // 'always_available' + 'deferred_direct_tool'
+            expect(turn2Tools?.map((t) => t.name)).toContain('always_available');
+            expect(turn2Tools?.map((t) => t.name)).toContain('deferred_direct_tool');
+            // Note: 'deferred_code_tool' is NOT in binding (code_execution only)
+            // Access system runnable - should rebuild due to stale flag
+            const turn2Runnable = ctx.systemRunnable;
+            expect(turn2Runnable).not.toBe(turn1Runnable); // Different instance = rebuilt
+            // Token count should increase (now includes deferred_code_tool in system message)
+            const turn2Tokens = ctx.instructionTokens;
+            expect(turn2Tokens).toBeGreaterThan(turn1Tokens);
+            // ========== TURN 3: Another turn, same discoveries ==========
+            // Same discoveries (duplicates)
+            const turn3Discoveries = ['deferred_direct_tool'];
+            const hasNewDiscoveriesTurn3 = ctx.markToolsAsDiscovered(turn3Discoveries);
+            expect(hasNewDiscoveriesTurn3).toBe(false); // No NEW discoveries
+            // Tools should be same as turn 2
+            const turn3Tools = ctx.getToolsForBinding();
+            expect(turn3Tools?.length).toBe(2);
+            // System runnable should be CACHED (same reference)
+            const turn3Runnable = ctx.systemRunnable;
+            expect(turn3Runnable).toBe(turn2Runnable); // Same instance = cached
+            // Token count unchanged
+            expect(ctx.instructionTokens).toBe(turn2Tokens);
+        });
+        it('maintains consistent indexTokenCountMap across turns', () => {
+            const ctx = createBasicContext({
+                agentConfig: { instructions: 'Base instructions' },
+                tokenCounter: mockTokenCounter,
+            });
+            // Initial setup (simulating fromConfig flow)
+            ctx.initializeSystemRunnable();
+            const initialSystemTokens = ctx.instructionTokens;
+            // Simulate message token counts from conversation
+            const messageTokenCounts = { '0': 50, '1': 100, '2': 75 };
+            ctx.updateTokenMapWithInstructions(messageTokenCounts);
+            // Verify token map: first message gets instruction tokens added
+            expect(ctx.indexTokenCountMap['0']).toBe(50 + initialSystemTokens);
+            expect(ctx.indexTokenCountMap['1']).toBe(100);
+            expect(ctx.indexTokenCountMap['2']).toBe(75);
+            // Simulate turn where system message changes
+            const toolRegistry = new Map([
+                [
+                    'new_code_tool',
+                    {
+                        name: 'new_code_tool',
+                        description: 'A newly discovered code-only tool with detailed documentation',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: true,
+                    },
+                ],
+            ]);
+            ctx.toolRegistry = toolRegistry;
+            // Discover the tool
+            ctx.markToolsAsDiscovered(['new_code_tool']);
+            // Access system runnable to trigger rebuild
+            void ctx.systemRunnable;
+            // Token count should have increased
+            const newSystemTokens = ctx.instructionTokens;
+            expect(newSystemTokens).toBeGreaterThan(initialSystemTokens);
+            // If we update token map again, it should use NEW instruction tokens
+            const newMessageTokenCounts = { '0': 60, '1': 110 };
+            ctx.updateTokenMapWithInstructions(newMessageTokenCounts);
+            expect(ctx.indexTokenCountMap['0']).toBe(60 + newSystemTokens);
+            expect(ctx.indexTokenCountMap['1']).toBe(110);
+        });
+        it('correctly tracks token delta when system message content changes', () => {
+            const toolRegistry = new Map([
+                [
+                    'tool_a',
+                    {
+                        name: 'tool_a',
+                        description: 'Short description',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: true,
+                    },
+                ],
+                [
+                    'tool_b',
+                    {
+                        name: 'tool_b',
+                        description: 'Another tool that adds more content',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: true,
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: {
+                    instructions: 'You are helpful.',
+                    toolRegistry,
+                },
+                tokenCounter: mockTokenCounter,
+            });
+            ctx.initializeSystemRunnable();
+            const baseTokens = ctx.instructionTokens;
+            // Discover tool_a
+            ctx.markToolsAsDiscovered(['tool_a']);
+            void ctx.systemRunnable;
+            const tokensAfterA = ctx.instructionTokens;
+            expect(tokensAfterA).toBeGreaterThan(baseTokens);
+            // Discover tool_b - adds more content
+            ctx.markToolsAsDiscovered(['tool_b']);
+            void ctx.systemRunnable;
+            const tokensAfterB = ctx.instructionTokens;
+            expect(tokensAfterB).toBeGreaterThan(tokensAfterA);
+            // Both deltas should be positive (each discovery adds tokens)
+            const deltaBaseToA = tokensAfterA - baseTokens;
+            const deltaAToB = tokensAfterB - tokensAfterA;
+            expect(deltaBaseToA).toBeGreaterThan(0);
+            expect(deltaAToB).toBeGreaterThan(0);
+        });
+        it('handles reset between runs correctly', () => {
+            const toolRegistry = new Map([
+                [
+                    'discovered_tool',
+                    {
+                        name: 'discovered_tool',
+                        description: 'Will be discovered',
+                        allowed_callers: ['code_execution'],
+                        defer_loading: true,
+                    },
+                ],
+            ]);
+            const ctx = createBasicContext({
+                agentConfig: {
+                    instructions: 'Assistant instructions',
+                    toolRegistry,
+                },
+                tokenCounter: mockTokenCounter,
+            });
+            // ========== RUN 1 ==========
+            ctx.initializeSystemRunnable();
+            ctx.markToolsAsDiscovered(['discovered_tool']);
+            void ctx.systemRunnable;
+            expect(ctx.discoveredToolNames.has('discovered_tool')).toBe(true);
+            const run1Tokens = ctx.instructionTokens;
+            expect(run1Tokens).toBeGreaterThan(0);
+            // ========== RESET (new run) ==========
+            ctx.reset();
+            // Verify state is cleared
+            expect(ctx.discoveredToolNames.size).toBe(0);
+            const resetTokens = ctx.instructionTokens;
+            expect(resetTokens).toBeGreaterThan(0);
+            expect(resetTokens).toBeLessThan(run1Tokens);
+            // ========== RUN 2 ==========
+            // Re-initialize (as fromConfig would do)
+            ctx.initializeSystemRunnable();
+            // System runnable should NOT include the previously discovered tool
+            // (because discoveredToolNames was cleared)
+            const run2Tokens = ctx.instructionTokens;
+            expect(run2Tokens).toBe(resetTokens);
+            // Token count should be lower than run 1 (no discovered tool in system message)
+            expect(run2Tokens).toBeLessThan(run1Tokens);
+            // Discover again
+            ctx.markToolsAsDiscovered(['discovered_tool']);
+            void ctx.systemRunnable;
+            // Now should match run 1
+            expect(ctx.instructionTokens).toBe(run1Tokens);
+        });
+    });
+});
+//# sourceMappingURL=AgentContext.test.js.map