🧰 feat: Add Opt-In Tool Result Caps and Coding Tool Allowlist

src/agents/AgentContext.ts

@@ -38,6 +38,7 @@ import {
 import {
   isProgrammaticRunnerAutoBound,
   isProgrammaticRunnerResolvedDirectly,
+  filterToolsByLocalAllowlist,
   resolveLocalImplementationNames,
   resolveLocalToolRegistry,
 } from '@/tools/local/resolveLocalExecutionTools';
@@ -183,7 +184,11 @@ export class AgentContext {
      * subagent) into this same array and must not mutate the host's input.
      */
     if (graphTools && graphTools.length > 0) {
-      agentContext.graphTools = [...graphTools];
+      agentContext.graphTools = [
+        ...((filterToolsByLocalAllowlist(graphTools, toolExecution) as
+          | t.GenericTool[]
+          | undefined) ?? []),
+      ] as t.GraphTools;
     }
 
     if (initialSummary?.text != null && initialSummary.text !== '') {
@@ -200,7 +205,28 @@ export class AgentContext {
       agentContext.baseIndexTokenCountMap = { ...tokenMap };
       agentContext.indexTokenCountMap = tokenMap;
 
-      if (toolSchemaTokens != null && toolSchemaTokens > 0) {
+      /** A cached total counts the host's unfiltered tools. Once the local
+       *  allowlist removed some, recount, but only when the recount can
+       *  measure every retained tool (it reads `.schema`); otherwise the
+       *  larger cached total is the safer budget. */
+      const allowlistRemovedTools =
+        (tools?.length ?? 0) !== (agentContext.tools?.length ?? 0) ||
+        (toolDefinitions?.length ?? 0) !==
+          (agentContext.toolDefinitions?.length ?? 0) ||
+        (graphTools?.length ?? 0) !== (agentContext.graphTools?.length ?? 0);
+      const recountMeasuresAll = [
+        ...((agentContext.tools as unknown[] | undefined) ?? []),
+        ...((agentContext.graphTools as unknown[] | undefined) ?? []),
+      ].every(
+        (tool) =>
+          tool != null &&
+          typeof (tool as { schema?: unknown }).schema === 'object'
+      );
+      if (
+        toolSchemaTokens != null &&
+        toolSchemaTokens > 0 &&
+        !(allowlistRemovedTools && recountMeasuresAll)
+      ) {
         /** Use pre-computed (cached) tool schema tokens — skip calculateInstructionTokens */
         agentContext.toolSchemaTokens = toolSchemaTokens;
         agentContext.tokenCalculationPromise = Promise.resolve();
@@ -537,14 +563,17 @@ export class AgentContext {
       tokenCounter != null && isTokenCounterCacheCompatible(tokenCounter)
         ? createExactTokenCountCache(tokenCounter)
         : undefined;
-    this.tools = tools;
+    this.tools = filterToolsByLocalAllowlist(tools, toolExecution);
     this.toolMap = toolMap;
     this.toolRegistry = resolveLocalToolRegistry({
       toolRegistry,
       toolExecution,
     });
     this.toolExecution = toolExecution;
-    this.toolDefinitions = toolDefinitions;
+    this.toolDefinitions = filterToolsByLocalAllowlist(
+      toolDefinitions as t.GraphTools | undefined,
+      toolExecution
+    ) as t.LCTool[] | undefined;
     this.instructions = instructions;
     this.additionalInstructions = additionalInstructions;
     if (reasoningKey) {

src/agents/__tests__/AgentContext.test.ts

@@ -69,6 +69,21 @@ describe('AgentContext', () => {
       expect(hostGraphTools).toHaveLength(1);
     });
 
+    it('drops graphTools outside the local coding allowlist', () => {
+      const runner = createMockTool('run_tools_with_code');
+      const askTool = createMockTool('ask_user_question');
+      const ctx = createBasicContext({
+        agentConfig: { graphTools: [runner, askTool] },
+        toolExecution: {
+          engine: 'local',
+          local: { codingToolNames: ['read_file'] },
+        },
+      });
+      expect(
+        (ctx.graphTools as t.GenericTool[]).map((tool) => tool.name)
+      ).toEqual(['ask_user_question']);
+    });
+
     it('leaves graphTools undefined when the host supplies none (or an empty list)', () => {
       expect(createBasicContext().graphTools).toBeUndefined();
       expect(
@@ -1794,6 +1809,51 @@ describe('AgentContext', () => {
       expect(ctx.instructionTokens).toBeGreaterThan(initialTokens);
     });
 
+    it('ignores a cached toolSchemaTokens total once the local allowlist removes tools', async () => {
+      const defs: t.LCTool[] = ['read_file', 'bash_tool'].map((name) => ({
+        name,
+        description: name,
+        parameters: { type: 'object', properties: {} },
+      }));
+      const toolExecution: t.ToolExecutionConfig = {
+        engine: 'local',
+        local: { codingToolNames: ['read_file'] },
+      };
+      const filtered = createBasicContext({
+        agentConfig: { toolDefinitions: defs, toolSchemaTokens: 99999 },
+        tokenCounter: mockTokenCounter,
+        toolExecution,
+      });
+      const unfiltered = createBasicContext({
+        agentConfig: { toolDefinitions: defs, toolSchemaTokens: 99999 },
+        tokenCounter: mockTokenCounter,
+      });
+      await filtered.tokenCalculationPromise;
+      await unfiltered.tokenCalculationPromise;
+      expect(filtered.toolSchemaTokens).not.toBe(99999);
+      expect(unfiltered.toolSchemaTokens).toBe(99999);
+    });
+
+    it('keeps the cached total when a retained tool is a native schema the recount cannot measure', async () => {
+      const nativeSearch = {
+        type: 'function',
+        function: { name: 'web_search', parameters: {} },
+      } as unknown as t.GenericTool;
+      const ctx = createBasicContext({
+        agentConfig: {
+          tools: [createMockTool('bash_tool'), nativeSearch],
+          toolSchemaTokens: 99999,
+        },
+        tokenCounter: mockTokenCounter,
+        toolExecution: {
+          engine: 'local',
+          local: { codingToolNames: ['read_file'] },
+        },
+      });
+      await ctx.tokenCalculationPromise;
+      expect(ctx.toolSchemaTokens).toBe(99999);
+    });
+
     it('excludes deferred-undiscovered toolDefinitions from toolSchemaTokens', async () => {
       const activeDef: t.LCTool = {
         name: 'active_tool',

src/session/AgentSession.ts

@@ -1720,7 +1720,9 @@ export class AgentSession {
         options.retainRecentTurns,
         options.instructions
       ),
-      this.runConfig.tokenCounter
+      this.runConfig.tokenCounter,
+      undefined,
+      this.runConfig.toolExecution
     );
     const graph = createManualCompactGraph({
       runId: compactRunId,

src/session/__tests__/JsonlSessionStore.test.ts

@@ -15,6 +15,7 @@ import { toJsonValue } from '@/session/messageSerialization';
 import * as providers from '@/llm/providers';
 import { GraphEvents } from '@/common';
 import { Run } from '@/run';
+import { AgentContext } from '@/agents/AgentContext';
 
 type MockRun = {
   processStream: jest.MockedFunction<Run<t.IState>['processStream']>;
@@ -178,6 +179,32 @@ describe('JsonlSessionStore', () => {
     expect(getPath).toHaveBeenCalledTimes(2);
   });
 
+  it('builds the manual compaction context with the run tool execution config', async () => {
+    mockSummarizer('summary of prior work');
+    mockRunCreate(createMockRun('answer'));
+    const toolExecution: t.ToolExecutionConfig = {
+      engine: 'local',
+      local: { codingToolNames: ['read_file'] },
+    };
+    const session = await createAgentSession({
+      cwd: dir,
+      sessionPath: join(dir, 'compact-tool-execution.jsonl'),
+      runId: 'template-run',
+      toolExecution,
+      graphConfig: {
+        type: 'standard',
+        llmConfig: { provider: 'openAI' as never, model: 'test-model' },
+        instructions: 'test',
+      },
+    });
+    await session.run('first');
+    const fromConfig = jest.spyOn(AgentContext, 'fromConfig');
+    await session.compact({ retainRecentTurns: 0 });
+    expect(fromConfig).toHaveBeenCalled();
+    expect(fromConfig.mock.calls.at(-1)?.[3]).toBe(toolExecution);
+    fromConfig.mockRestore();
+  });
+
   it('keeps the unexposed cache coherent through compaction, HITL resume, branching, and reopening', async () => {
     mockSummarizer('summary of prior work');
     const mockRun = createMockRun('answer');