Bug: disableTools and allowedTools ignored during tool initialization in rc168

[buger]

Summary

ProbeAgent rc168 claims to support disableTools and allowedTools options (as documented in TypeScript definitions), but these options are ignored during tool initialization. All tools are created regardless of configuration, though they are correctly filtered later in the system message and parsing logic.

Evidence from Visor Integration

When Visor passes disableTools: true and allowedTools: [] to ProbeAgent:

[2025-11-22T06:58:30.304Z] [debug] 🔧 Setting allowedTools: []
[2025-11-22T06:58:30.304Z] [debug] 🔧 Setting disableTools: true
[DEBUG] ProbeAgent Tools Initialized
[DEBUG] Available tools:
[DEBUG]   - search
[DEBUG]   - query
[DEBUG]   - extract
[DEBUG]   - delegate
[DEBUG]   - listFiles
[DEBUG]   - searchFiles
[DEBUG]   - readImage

All 7 tools are initialized despite disableTools: true being set.

Root Cause Analysis

File: src/agent/ProbeAgent.js

Lines 151-155 - Options are correctly parsed:

// disableTools is a convenience flag that overrides allowedTools to []
const effectiveAllowedTools = options.disableTools ? [] : options.allowedTools;
this.allowedTools = this._parseAllowedTools(effectiveAllowedTools);

Lines 424-434 - THE BUG: Tool initialization doesn't check allowedTools:

const configOptions = {
  sessionId: this.sessionId,
  debug: this.debug,
  defaultPath: this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd(),
  allowedFolders: this.allowedFolders,
  outline: this.outline,
  enableBash: this.enableBash,
  bashConfig: this.bashConfig
  // ❌ Missing: allowedTools and disableTools are NOT passed!
};

// Create base tools
const baseTools = createTools(configOptions);

File: src/agent/tools.js

Lines 33-53 - createTools() always creates all core tools:

export function createTools(configOptions) {
  const tools = {
    searchTool: searchTool(configOptions),
    queryTool: queryTool(configOptions),
    extractTool: extractTool(configOptions),
    delegateTool: delegateTool(configOptions)
  };
  // ❌ No check for allowedTools/disableTools before creating tools!

  // Only checks enableBash and allowEdit:
  if (configOptions.enableBash) {
    tools.bashTool = bashTool(configOptions);
  }
  if (configOptions.allowEdit) {
    tools.editTool = editTool(configOptions);
    tools.createTool = createTool(configOptions);
  }

  return tools;
}

Impact

1. Misleading debug output - Shows tools as "available" when they're actually disabled
2. Resource waste - Creates tool instances that will never be used
3. Architectural inconsistency - Options are parsed but not enforced during initialization

Note: Tools ARE correctly filtered in:

• System message generation (lines 1611-1622 in ProbeAgent.js)
• Tool response parsing (lines 2314-2322 in ProbeAgent.js)

So the tools can't actually be used, but they're still created and logged.

Proposed Fix

Option 1: Pass allowedTools to createTools()

In ProbeAgent.js, line 424:

const configOptions = {
  sessionId: this.sessionId,
  debug: this.debug,
  defaultPath: this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd(),
  allowedFolders: this.allowedFolders,
  outline: this.outline,
  enableBash: this.enableBash,
  bashConfig: this.bashConfig,
  allowedTools: this.allowedTools  // ADD THIS
};

In tools.js, lines 33-53:

export function createTools(configOptions) {
  const tools = {};

  // Helper to check if a tool is allowed
  const isToolAllowed = (toolName) => {
    if (!configOptions.allowedTools) return true;
    return configOptions.allowedTools.isEnabled(toolName);
  };

  // Only create allowed tools
  if (isToolAllowed('search')) {
    tools.searchTool = searchTool(configOptions);
  }
  if (isToolAllowed('query')) {
    tools.queryTool = queryTool(configOptions);
  }
  if (isToolAllowed('extract')) {
    tools.extractTool = extractTool(configOptions);
  }
  if (isToolAllowed('delegate')) {
    tools.delegateTool = delegateTool(configOptions);
  }

  // Add bash tool if enabled AND allowed
  if (configOptions.enableBash && isToolAllowed('bash')) {
    tools.bashTool = bashTool(configOptions);
  }

  // Add edit and create tools if enabled AND allowed
  if (configOptions.allowEdit && isToolAllowed('edit')) {
    tools.editTool = editTool(configOptions);
  }
  if (configOptions.allowEdit && isToolAllowed('create')) {
    tools.createTool = createTool(configOptions);
  }

  return tools;
}

Option 2: Filter tools after creation

In ProbeAgent.js, after line 434:

const baseTools = createTools(configOptions);

// Filter tools based on allowedTools configuration
const filteredTools = {};
for (const [key, value] of Object.entries(baseTools)) {
  const toolName = key.replace('Tool', ''); // searchTool -> search
  if (this.allowedTools.isEnabled(toolName)) {
    filteredTools[key] = value;
  }
}

// Create wrapped tools with event emission
const wrappedTools = createWrappedTools(filteredTools);

Reproduction

1. Install ProbeAgent 0.6.0-rc168
2. Create a ProbeAgent instance with disableTools: true:

   const agent = new ProbeAgent({
     debug: true,
     disableTools: true
   });
   await agent.initialize();

3. Observe debug output shows all tools initialized
4. Expected: No tools should be initialized

Test Case

describe('ProbeAgent tool filtering', () => {
  it('should not initialize tools when disableTools is true', async () => {
    const agent = new ProbeAgent({
      disableTools: true
    });
    await agent.initialize();

    // toolImplementations should be empty or only contain MCP tools
    expect(agent.toolImplementations.search).toBeUndefined();
    expect(agent.toolImplementations.query).toBeUndefined();
  });

  it('should only initialize allowed tools', async () => {
    const agent = new ProbeAgent({
      allowedTools: ['search', 'query']
    });
    await agent.initialize();

    expect(agent.toolImplementations.search).toBeDefined();
    expect(agent.toolImplementations.query).toBeDefined();
    expect(agent.toolImplementations.extract).toBeUndefined();
    expect(agent.toolImplementations.delegate).toBeUndefined();
  });
});

Related Code

• ProbeAgent.js:151-155 - Options parsing (works correctly)
• ProbeAgent.js:243-281 - _parseAllowedTools() method (works correctly)
• ProbeAgent.js:424-434 - Tool initialization (BUG HERE)
• ProbeAgent.js:1611-1622 - System message filtering (works correctly)
• ProbeAgent.js:2314-2322 - Tool parsing filtering (works correctly)
• tools.js:33-53 - createTools() function (BUG HERE)

Additional Context

This bug was discovered while integrating ProbeAgent rc168 into Visor (https://github.com/probelabs/visor), a workflow orchestration tool. Visor added support for the new disableTools option but observed that all tools were still being initialized and logged in debug output, despite the tools being correctly filtered from the AI's system message and tool execution.

Environment

• ProbeAgent version: 0.6.0-rc168
• Node.js version: 14.16.0+
• Integration: Visor workflow orchestration tool

[probelabs]

• INFO: {
  "text": "# Bug Analysis: Tool Initialization Ignoring disableTools and allowedTools\n\nThank you for this detailed bug report! I've analyzed the code and can confirm the issue you've identified. This is indeed a bug where the disableTools and allowedTools options are parsed correctly but not enforced during tool initialization.\n\n## Issue Confirmation\n\n✅ Bug Verified: The allowedTools configuration is parsed in the constructor (lines 153-155) but is not passed to the createTools() function (lines 424-434), causing all tools to be created regardless of the configuration.\n\n## Root Cause Analysis\n\nYour analysis is spot on. The issue occurs in two places:\n\n1. npm/src/agent/ProbeAgent.js:424-434: The configOptions object passed to createTools() is missing the allowedTools property\n2. npm/src/agent/tools.js:34-49: The createTools() function creates all tools without checking allowedTools configuration\n\n## Impact Assessment\n\n- Resource Waste: Tool instances are created unnecessarily\n- Misleading Debug Output: Shows tools as "available" when they're actually disabled\n- Architectural Inconsistency: Options are parsed but not enforced during initialization\n\n## Correct Filtering Locations\n\nI can confirm that tool filtering does work correctly in:\n- System message generation (lines 1614-1622) using isToolAllowed() helper\n- Tool response parsing (lines 2324-2334) using this.allowedTools.isEnabled()\n\n## Recommended Solution\n\nOption 1 (passing allowedTools to createTools()) is preferred as it prevents unnecessary tool creation:\n\n### In npm/src/agent/ProbeAgent.js (around line 424):\njavascript\nconst configOptions = {\n sessionId: this.sessionId,\n debug: this.debug,\n defaultPath: this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd(),\n allowedFolders: this.allowedFolders,\n outline: this.outline,\n enableBash: this.enableBash,\n bashConfig: this.bashConfig,\n allowedTools: this.allowedTools // ADD THIS\n};\n\n\n### In npm/src/agent/tools.js (lines 34-49):\njavascript\nexport function createTools(configOptions) {\n const tools = {};\n\n // Helper to check if a tool is allowed\n const isToolAllowed = (toolName) => {\n if (!configOptions.allowedTools) return true;\n return configOptions.allowedTools.isEnabled(toolName);\n };\n\n // Only create allowed tools\n if (isToolAllowed('search')) {\n tools.searchTool = searchTool(configOptions);\n }\n if (isToolAllowed('query')) {\n tools.queryTool = queryTool(configOptions);\n }\n if (isToolAllowed('extract')) {\n tools.extractTool = extractTool(configOptions);\n }\n if (isToolAllowed('delegate')) {\n tools.delegateTool = delegateTool(configOptions);\n }\n\n // Add bash tool if enabled AND allowed\n if (configOptions.enableBash && isToolAllowed('bash')) {\n tools.bashTool = bashTool(configOptions);\n }\n\n // Add edit and create tools if enabled AND allowed\n if (configOptions.allowEdit && isToolAllowed('implement')) {\n tools.editTool = editTool(configOptions);\n tools.createTool = createTool(configOptions);\n }\n\n return tools;\n}\n\n\n## Test Case Validation\n\nYour proposed test cases are excellent and would catch this bug:\n\njavascript\ndescribe('ProbeAgent tool filtering', () => {\n it('should not initialize tools when disableTools is true', async () => {\n const agent = new ProbeAgent({ disableTools: true });\n await agent.initialize();\n expect(agent.toolImplementations.search).toBeUndefined();\n expect(agent.toolImplementations.query).toBeUndefined();\n });\n\n it('should only initialize allowed tools', async () => {\n const agent = new ProbeAgent({ allowedTools: ['search', 'query'] });\n await agent.initialize();\n expect(agent.toolImplementations.search).toBeDefined();\n expect(agent.toolImplementations.query).toBeDefined();\n expect(agent.toolImplementations.extract).toBeUndefined();\n });\n});\n\n\n## Next Steps\n\n1. Implement the fix using Option 1 (preferred approach)\n2. Add test cases to prevent regression\n3. Update debug logging to reflect actual tool availability\n4. Consider adding validation to ensure allowedTools is always passed where needed\n\nThis is a well-documented bug with a clear path to resolution. The fix should be straightforward and will improve both resource efficiency and debugging experience.\n\n## References\n\n- npm/src/agent/ProbeAgent.js:153-155 – Options parsing (works correctly)\n- npm/src/agent/ProbeAgent.js:424-434 – Tool initialization (BUG HERE)\n- npm/src/agent/tools.js:34-49 – createTools() function (BUG HERE)\n- npm/src/agent/ProbeAgent.js:1614-1622 – System message filtering (works correctly)\n- npm/src/agent/ProbeAgent.js:2324-2334 – Tool parsing filtering (works correctly)",
  "intent": "issue_triage",
  "labels": ["bug", "tool-filtering", "resource-management", "high-priority"]
  } (AI_RESPONSE:1)

---

Powered by Visor from Probelabs

💡 TIP: You can chat with Visor using /visor ask <your question>