@ai-sdk/harness 1.0.11 → 1.0.12

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @ai-sdk/harness
 
+## 1.0.12
+
+### Patch Changes
+
+- 7859cea: feat(harness): add tool filtering via `activeTools` and `inactiveTools`
+- c857346: feat(harness): add utility functions for certain duplicated layers in harnesses
+
 ## 1.0.11
 
 ### Patch Changes

package/agent/index.ts

@@ -1,4 +1,5 @@
 export { HarnessAgent } from '../src/agent/harness-agent';
+export type { HarnessAllTools } from '../src/agent/harness-agent-tool-types';
 export type {
   HarnessAgentSandboxConfig,
   HarnessAgentSettings,

package/dist/agent/index.d.ts

@@ -1,6 +1,6 @@
 import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
 import { Experimental_SandboxSession, UserModelMessage, ToolSet, FlexibleSchema, Tool, ToolApprovalResponse, ModelMessage, Context } from '@ai-sdk/provider-utils';
-import { ToolApprovalStatus, TelemetryOptions, StreamTextResult, Agent, AgentCallParameters, GenerateTextResult, AgentStreamParameters, Telemetry } from 'ai';
+import { ToolApprovalStatus, TelemetryOptions, ActiveTools, StreamTextResult, Agent, AgentCallParameters, GenerateTextResult, AgentStreamParameters, Telemetry } from 'ai';
 import { z } from 'zod/v4';
 import { JSONValue, LanguageModelV4ToolCall, LanguageModelV4ToolApprovalRequest, LanguageModelV4ToolResult, LanguageModelV4FinishReason, LanguageModelV4Usage, JSONSchema7, AISDKError } from '@ai-sdk/provider';
 
@@ -585,6 +585,14 @@ type HarnessV1ToolSpec = {
     readonly inputSchema?: JSONSchema7;
 };
 
+type HarnessV1BuiltinToolFiltering = {
+    mode: 'allow';
+    toolNames: string[];
+} | {
+    mode: 'deny';
+    toolNames: string[];
+};
+
 /**
  * Options passed to `HarnessV1.doStart`.
  *
@@ -622,6 +630,12 @@ type HarnessV1StartOptions = {
      * the adapter.
      */
     readonly permissionMode?: HarnessV1PermissionMode;
+    /**
+     * Adapter-native built-in tools that should be available for this session.
+     * Custom host-executed tools are filtered by the framework before they reach
+     * the adapter.
+     */
+    readonly builtinToolFiltering?: HarnessV1BuiltinToolFiltering;
     /**
      * Signal that aborts startup. The adapter must propagate cancellation to
      * any spawned processes or network calls.
@@ -858,6 +872,16 @@ type HarnessV1<TBuiltinTools extends ToolSet = ToolSet> = {
      * only describes adapter-native tool approval support.
      */
     readonly supportsBuiltinToolApprovals?: boolean;
+    /**
+     * Whether the adapter can prevent its underlying runtime from seeing or
+     * calling inactive built-in tools for every tool in `builtinTools`.
+     *
+     * Adapters without native filtering can still support `activeTools` and
+     * `inactiveTools` for built-ins when `supportsBuiltinToolApprovals` is
+     * `true`: the framework routes inactive built-in tool calls through the
+     * approval path and auto-denies them before they execute.
+     */
+    readonly supportsBuiltinToolFiltering?: boolean;
     /**
      * Optional schema for the adapter-defined `data` payload returned by session
      * lifecycle methods. When present, the adapter promises that exported state
@@ -1038,6 +1062,14 @@ type HarnessAgentPendingToolApproval = HarnessV1PendingToolApproval;
 type HarnessAgentSkill = HarnessV1Skill;
 type HarnessAgentPermissionMode = HarnessV1PermissionMode;
 
+/** Extract the builtin tool set type from a harness adapter parameter. */
+type HarnessBuiltinToolsOf<H> = H extends HarnessAgentAdapter<infer T> ? T : never;
+/**
+ * Type-level merge of a harness's builtin tools with user-defined tools.
+ * User tools override builtins on key collision.
+ */
+type HarnessAllTools<THarness extends HarnessAgentAdapter<any>, TUserTools extends ToolSet> = Omit<HarnessBuiltinToolsOf<THarness>, keyof TUserTools> & TUserTools;
+
 type HarnessAgentToolApprovalConfiguration = Readonly<Record<string, ToolApprovalStatus>>;
 type HarnessAgentSandboxConfig = {
     /**
@@ -1077,6 +1109,7 @@ type HarnessAgentSandboxConfig = {
         readonly abortSignal?: AbortSignal;
     }) => Promise<void>;
 };
+type HarnessTools<TOOLS extends ToolSet> = ActiveTools<NoInfer<TOOLS>>;
 /**
  * Construction-time settings for a `HarnessAgent`.
  *
@@ -1084,6 +1117,21 @@ type HarnessAgentSandboxConfig = {
  * `AgentCallParameters` / `AgentStreamParameters` passed to `generate` /
  * `stream` and are not duplicated here.
  */
+type HarnessAgentToolFilteringSettings<TOOLS extends ToolSet> = {
+    /**
+     * Limits the tools that are available for the harness to call without
+     * changing the tool call and result types in the result.
+     */
+    readonly activeTools?: HarnessTools<TOOLS>;
+    readonly inactiveTools?: never;
+} | {
+    readonly activeTools?: never;
+    /**
+     * Excludes tools from the set that is available for the harness to call
+     * without changing the tool call and result types in the result.
+     */
+    readonly inactiveTools?: HarnessTools<TOOLS>;
+};
 type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}> = {
     /**
      * The harness adapter driving the underlying agent runtime. Its
@@ -1165,7 +1213,7 @@ type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAge
      * stderr default — wire this to capture diagnostics in code.
      */
     readonly onLog?: (event: HarnessDiagnostic) => void;
-};
+} & HarnessAgentToolFilteringSettings<HarnessAllTools<THarness, TUserTools>>;
 
 type HarnessAgentToolApprovalContinuation = {
     readonly approvalResponse: ToolApprovalResponse;
@@ -1250,7 +1298,9 @@ declare class HarnessAgentSession {
         prompt: HarnessAgentPrompt;
         instructions: string | undefined;
         tools: TOOLS;
+        activeTools: ToolSet;
         toolSpecs: HarnessAgentToolSpec[];
+        builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
         runtimeContext: RUNTIME_CONTEXT;
         abortSignal: AbortSignal | undefined;
         telemetry: TelemetryOptions | undefined;
@@ -1258,7 +1308,9 @@ declare class HarnessAgentSession {
     continueTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context>(options: {
         instructions: string | undefined;
         tools: TOOLS;
+        activeTools: ToolSet;
         toolSpecs: HarnessAgentToolSpec[];
+        builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
         runtimeContext: RUNTIME_CONTEXT;
         abortSignal: AbortSignal | undefined;
         telemetry: TelemetryOptions | undefined;
@@ -1322,13 +1374,6 @@ declare class HarnessAgentSession {
     private requireReusableSession;
 }
 
-/** Extract the builtin tool set type from a harness adapter parameter. */
-type BuiltinToolsOf<H> = H extends HarnessAgentAdapter<infer T> ? T : never;
-/**
- * Type-level merge of a harness's builtin tools with user-defined tools.
- * User tools override builtins on key collision.
- */
-type HarnessAllTools<THarness extends HarnessAgentAdapter<any>, TUserTools extends ToolSet> = Omit<BuiltinToolsOf<THarness>, keyof TUserTools> & TUserTools;
 /**
  * Required `session` extension on every `HarnessAgent.generate` /
  * `HarnessAgent.stream` call. The agent operates exclusively on the
@@ -1387,7 +1432,8 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
     readonly tools: HarnessAllTools<THarness, TUserTools>;
     private readonly settings;
     private readonly sandboxConfig;
-    private readonly userTools;
+    private readonly activeUserTools;
+    private readonly builtinToolFiltering;
     private readonly permissionMode;
     constructor(settings: HarnessAgentSettings<THarness, TUserTools>);
     /** Identifier of the harness backing this agent. */
@@ -1565,4 +1611,4 @@ interface TraceTreeReporterOptions {
 }
 declare function createTraceTreeReporter(options?: TraceTreeReporterOptions): Telemetry;
 
-export { type FileReporter, type FileReporterOptions, HarnessAgent, type HarnessAgentAdapter, type HarnessAgentAdapterSession, type HarnessAgentBuiltinTool, type HarnessAgentBuiltinToolName, type HarnessAgentBuiltinToolUseKind, type HarnessAgentBuiltinTools, type HarnessAgentContinueTurnOptions, type HarnessAgentContinueTurnState, type HarnessAgentLifecycleState, type HarnessAgentPendingToolApproval, type HarnessAgentPermissionMode, type HarnessAgentPrompt, type HarnessAgentPromptControl, type HarnessAgentPromptTurnOptions, type HarnessAgentResumeSessionState, type HarnessAgentSandboxConfig, HarnessAgentSession, type HarnessAgentSettings, type HarnessAgentSkill, type HarnessAgentStartOptions, type HarnessAgentStreamPart, type HarnessAgentToolApprovalConfiguration, type HarnessAgentToolApprovalContinuation, type HarnessAgentToolSpec, HarnessCapabilityUnsupportedError, type HarnessDebugConfig, type HarnessDebugLevel, type HarnessDiagnostic, type HarnessDiagnosticConsumer, HarnessError, type PrepareSandboxForHarnessResult, type TraceTreeReporterOptions, collectHarnessAgentToolApprovalContinuations, createFileReporter, createTraceTreeReporter, prepareHarnessSandboxTemplate, prepareSandboxForHarness, prewarmHarness };
+export { type FileReporter, type FileReporterOptions, HarnessAgent, type HarnessAgentAdapter, type HarnessAgentAdapterSession, type HarnessAgentBuiltinTool, type HarnessAgentBuiltinToolName, type HarnessAgentBuiltinToolUseKind, type HarnessAgentBuiltinTools, type HarnessAgentContinueTurnOptions, type HarnessAgentContinueTurnState, type HarnessAgentLifecycleState, type HarnessAgentPendingToolApproval, type HarnessAgentPermissionMode, type HarnessAgentPrompt, type HarnessAgentPromptControl, type HarnessAgentPromptTurnOptions, type HarnessAgentResumeSessionState, type HarnessAgentSandboxConfig, HarnessAgentSession, type HarnessAgentSettings, type HarnessAgentSkill, type HarnessAgentStartOptions, type HarnessAgentStreamPart, type HarnessAgentToolApprovalConfiguration, type HarnessAgentToolApprovalContinuation, type HarnessAgentToolSpec, type HarnessAllTools, HarnessCapabilityUnsupportedError, type HarnessDebugConfig, type HarnessDebugLevel, type HarnessDiagnostic, type HarnessDiagnosticConsumer, HarnessError, type PrepareSandboxForHarnessResult, type TraceTreeReporterOptions, collectHarnessAgentToolApprovalContinuations, createFileReporter, createTraceTreeReporter, prepareHarnessSandboxTemplate, prepareSandboxForHarness, prewarmHarness };

package/dist/agent/index.js

@@ -131,6 +131,15 @@ async function validateLifecycleStateData(input) {
   };
 }
 
+// src/v1/harness-v1-tool-filtering.ts
+function isHarnessV1BuiltinToolIncluded(input) {
+  if (input.toolFiltering == null) return true;
+  return input.toolFiltering.mode === "allow" ? input.toolFiltering.toolNames.includes(input.toolName) : !input.toolFiltering.toolNames.includes(input.toolName);
+}
+function getHarnessV1BuiltinToolFilteringDenialReason(input) {
+  return `Tool '${input.toolName}' is inactive due to the HarnessAgent tool filtering policy.`;
+}
+
 // src/agent/internal/to-harness-stream.ts
 async function toHarnessStream(options) {
   let controller;
@@ -1162,7 +1171,7 @@ function normalizeToolApprovalStatus(input) {
 
 // src/agent/internal/run-prompt.ts
 function runPrompt(input) {
-  var _a3, _b3, _c;
+  var _a3, _b3, _c, _d;
   const result = new HarnessStreamTextResult({
     tools: input.tools,
     runtimeContext: input.runtimeContext,
@@ -1176,6 +1185,7 @@ function runPrompt(input) {
   });
   const onToolApprovalSettled = (_c = input.onToolApprovalSettled) != null ? _c : (() => {
   });
+  const activeTools = (_d = input.activeTools) != null ? _d : input.tools;
   const telemetry = createTurnTelemetry({
     telemetry: input.telemetry,
     harnessId: input.harness.harnessId,
@@ -1185,7 +1195,7 @@ function runPrompt(input) {
     runtimeContext: input.runtimeContext
   });
   const done = (async () => {
-    var _a4, _b4, _c2, _d, _e, _f, _g;
+    var _a4, _b4, _c2, _d2, _e, _f, _g, _h;
     let bridge;
     try {
       bridge = await toHarnessStream({
@@ -1348,7 +1358,7 @@ function runPrompt(input) {
       };
       const outcome = await maybeExecuteHostTool({
         event: rawToolCall,
-        tools: input.tools,
+        tools: activeTools,
         sandboxSession: input.sandboxSession,
         abortSignal: input.abortSignal,
         control,
@@ -1396,6 +1406,36 @@ function runPrompt(input) {
         if (settledApprovalToolCallReplay) {
           continue;
         }
+        if (displayValue.type === "tool-approval-request") {
+          const toolCall = toolCallsByToolCallId.get(displayValue.toolCallId);
+          if (toolCall == null) {
+            throw new Error(
+              `Harness '${input.harness.harnessId}' emitted approval request '${displayValue.approvalId}' for unknown tool call '${displayValue.toolCallId}'.`
+            );
+          }
+          const rawToolCall = rawToolCallsByToolCallId.get(
+            displayValue.toolCallId
+          );
+          const toolName = (_c2 = rawToolCall == null ? void 0 : rawToolCall.toolName) != null ? _c2 : toolCall.toolName;
+          if (!isHarnessV1BuiltinToolIncluded({
+            toolName,
+            toolFiltering: input.builtinToolFiltering
+          })) {
+            if (control.submitToolApproval == null) {
+              throw new Error(
+                `Harness '${input.harness.harnessId}' emitted a built-in tool approval request but does not support approval responses.`
+              );
+            }
+            await control.submitToolApproval({
+              approvalId: displayValue.approvalId,
+              approved: false,
+              reason: getHarnessV1BuiltinToolFilteringDenialReason({
+                toolName
+              })
+            });
+            continue;
+          }
+        }
         for (const part of translateStreamPart(displayValue)) {
           result.enqueue(part);
         }
@@ -1441,13 +1481,13 @@ function runPrompt(input) {
             );
           }
           const rawToolCall = rawToolCallsByToolCallId.get(value.toolCallId);
-          const pendingApproval = (_e = pendingApprovalsByApprovalId.get(value.approvalId)) != null ? _e : {
+          const pendingApproval = (_f = pendingApprovalsByApprovalId.get(value.approvalId)) != null ? _f : {
             approvalId: value.approvalId,
             toolCallId: value.toolCallId,
             toolName: toolCall.toolName,
-            input: (_c2 = rawToolCall == null ? void 0 : rawToolCall.input) != null ? _c2 : JSON.stringify(toolCall.input),
+            input: (_d2 = rawToolCall == null ? void 0 : rawToolCall.input) != null ? _d2 : JSON.stringify(toolCall.input),
             kind: "builtin",
-            providerExecuted: (_d = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _d : true,
+            providerExecuted: (_e = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _e : true,
             ...(rawToolCall == null ? void 0 : rawToolCall.nativeName) !== void 0 ? { nativeName: rawToolCall.nativeName } : {}
           };
           pendingApprovalsByApprovalId.set(
@@ -1506,6 +1546,20 @@ function runPrompt(input) {
               `Harness '${input.harness.harnessId}' could not find parsed tool call '${toolCall.toolCallId}' for custom tool approval.`
             );
           }
+          if (!hasTool({ tools: activeTools, toolName: toolCall.toolName })) {
+            const output = {
+              type: "execution-denied",
+              reason: getHarnessV1BuiltinToolFilteringDenialReason({
+                toolName: toolCall.toolName
+              })
+            };
+            await control.submitToolResult({
+              toolCallId: toolCall.toolCallId,
+              output
+            });
+            telemetry.toolEnd(toolCall.toolCallId, { ok: true, output });
+            continue;
+          }
           const customToolApprovalDecision = resolveCustomToolApproval({
             toolName: toolCall.toolName,
             toolApproval: input.toolApproval
@@ -1535,7 +1589,7 @@ function runPrompt(input) {
             telemetry.toolEnd(toolCall.toolCallId, { ok: true, output });
             continue;
           }
-          const pendingApproval = (_f = pendingApprovalsByToolCallId.get(toolCall.toolCallId)) != null ? _f : customToolApprovalDecision.type === "request" ? {
+          const pendingApproval = (_g = pendingApprovalsByToolCallId.get(toolCall.toolCallId)) != null ? _g : customToolApprovalDecision.type === "request" ? {
             approvalId: generateId4(),
             toolCallId: toolCall.toolCallId,
             toolName: toolCall.toolName,
@@ -1581,7 +1635,7 @@ function runPrompt(input) {
           }
           const outcome = await maybeExecuteHostTool({
             event: toolCall,
-            tools: input.tools,
+            tools: activeTools,
             sandboxSession: input.sandboxSession,
             abortSignal: input.abortSignal,
             control,
@@ -1613,7 +1667,7 @@ function runPrompt(input) {
           return;
         }
       }
-      (_g = input.onTurnFinished) == null ? void 0 : _g.call(input);
+      (_h = input.onTurnFinished) == null ? void 0 : _h.call(input);
       await result.finish(
         finalFinish ? {
           finishReason: finalFinish.finishReason,
@@ -1640,6 +1694,9 @@ function asToolCallTextStreamPart(input) {
   }
   return input.part;
 }
+function hasTool(input) {
+  return Object.prototype.hasOwnProperty.call(input.tools, input.toolName);
+}
 async function maybeExecuteHostTool(input) {
   const tool = input.tools[input.event.toolName];
   if (!isExecutableTool(tool)) return { ok: true, output: void 0 };
@@ -1767,7 +1824,9 @@ var HarnessAgentSession = class {
         prompt: options.prompt,
         instructions: options.instructions,
         tools: options.tools,
+        activeTools: options.activeTools,
         toolSpecs: options.toolSpecs,
+        builtinToolFiltering: options.builtinToolFiltering,
         sandboxSession: sandboxSession.restricted(),
         sessionWorkDir: this.sessionWorkDir,
         runtimeContext: options.runtimeContext,
@@ -1805,7 +1864,9 @@ var HarnessAgentSession = class {
         mode: "continue",
         instructions: options.instructions,
         tools: options.tools,
+        activeTools: options.activeTools,
         toolSpecs: options.toolSpecs,
+        builtinToolFiltering: options.builtinToolFiltering,
         sandboxSession: sandboxSession.restricted(),
         sessionWorkDir: this.sessionWorkDir,
         runtimeContext: options.runtimeContext,
@@ -2458,6 +2519,66 @@ function buildObservability(options) {
   };
 }
 
+// src/agent/internal/tool-filtering.ts
+import { NoSuchToolError } from "ai";
+function resolveHarnessAgentToolFiltering(input) {
+  if (input.activeTools !== void 0 && input.inactiveTools !== void 0) {
+    throw new Error(
+      "HarnessAgent: pass either `activeTools` or `inactiveTools`, not both."
+    );
+  }
+  const allToolNames = Object.keys(input.allTools);
+  const activeTools = dedupeToolNames({ toolNames: input.activeTools });
+  const inactiveTools = dedupeToolNames({ toolNames: input.inactiveTools });
+  validateToolNames({
+    requestedToolNames: activeTools != null ? activeTools : inactiveTools,
+    availableToolNames: allToolNames
+  });
+  const userToolNames = Object.keys(input.userTools);
+  const activeUserToolNames = activeTools != null ? userToolNames.filter((name3) => activeTools.includes(name3)) : inactiveTools != null ? userToolNames.filter((name3) => !inactiveTools.includes(name3)) : userToolNames;
+  const builtinToolNames = Object.keys(input.harness.builtinTools);
+  const disabledBuiltinToolNames = activeTools != null ? builtinToolNames.filter((name3) => !activeTools.includes(name3)) : inactiveTools != null ? builtinToolNames.filter((name3) => inactiveTools.includes(name3)) : [];
+  const builtinToolFiltering = disabledBuiltinToolNames.length > 0 ? activeTools != null ? {
+    mode: "allow",
+    toolNames: builtinToolNames.filter(
+      (name3) => activeTools.includes(name3)
+    )
+  } : { mode: "deny", toolNames: disabledBuiltinToolNames } : void 0;
+  if (builtinToolFiltering != null && input.harness.supportsBuiltinToolFiltering !== true && input.harness.supportsBuiltinToolApprovals !== true) {
+    throw new HarnessCapabilityUnsupportedError({
+      message: `Harness '${input.harness.harnessId}' does not support built-in tool filtering controls.`,
+      harnessId: input.harness.harnessId
+    });
+  }
+  return {
+    activeUserTools: filterToolSet({
+      tools: input.userTools,
+      toolNames: activeUserToolNames
+    }),
+    ...builtinToolFiltering != null ? { builtinToolFiltering } : {}
+  };
+}
+function dedupeToolNames(input) {
+  return input.toolNames == null ? void 0 : Array.from(new Set(input.toolNames));
+}
+function validateToolNames(input) {
+  if (input.requestedToolNames == null) return;
+  for (const toolName of input.requestedToolNames) {
+    if (!input.availableToolNames.includes(toolName)) {
+      throw new NoSuchToolError({
+        toolName,
+        availableTools: [...input.availableToolNames]
+      });
+    }
+  }
+}
+function filterToolSet(input) {
+  const allowed = new Set(input.toolNames);
+  return Object.fromEntries(
+    Object.entries(input.tools).filter(([name3]) => allowed.has(name3))
+  );
+}
+
 // src/agent/harness-agent.ts
 var HarnessAgent = class {
   constructor(settings) {
@@ -2468,10 +2589,23 @@ var HarnessAgent = class {
     this.settings = settings;
     this.sandboxConfig = sandboxConfig;
     this.id = settings.id;
-    this.userTools = (_a3 = settings.tools) != null ? _a3 : {};
+    const userTools = (_a3 = settings.tools) != null ? _a3 : {};
     this.permissionMode = resolvePermissionMode({
       permissionMode: settings.permissionMode
     });
+    const tools = {
+      ...settings.harness.builtinTools,
+      ...userTools
+    };
+    const toolFiltering = resolveHarnessAgentToolFiltering({
+      harness: settings.harness,
+      userTools,
+      allTools: tools,
+      activeTools: settings.activeTools,
+      inactiveTools: settings.inactiveTools
+    });
+    this.activeUserTools = toolFiltering.activeUserTools;
+    this.builtinToolFiltering = toolFiltering.builtinToolFiltering;
     if (Object.keys(settings.harness.builtinTools).length > 0 && permissionModeNeedsBuiltinSupport({
       permissionMode: this.permissionMode
     }) && settings.harness.supportsBuiltinToolApprovals !== true) {
@@ -2480,10 +2614,7 @@ var HarnessAgent = class {
         harnessId: settings.harness.harnessId
       });
     }
-    this.tools = {
-      ...settings.harness.builtinTools,
-      ...this.userTools
-    };
+    this.tools = tools;
   }
   /** Identifier of the harness backing this agent. */
   get harnessId() {
@@ -2592,6 +2723,7 @@ var HarnessAgent = class {
         resumeFrom: validatedResumeFrom,
         continueFrom: effectiveContinueFrom,
         permissionMode: this.permissionMode,
+        builtinToolFiltering: this.builtinToolFiltering,
         abortSignal,
         observability: buildObservability({ settings: this.settings })
       };
@@ -2693,7 +2825,9 @@ var HarnessAgent = class {
       return input.session.continueTurn({
         instructions: this.settings.instructions,
         tools: this.tools,
+        activeTools: this.activeUserTools,
         toolSpecs: this._toToolSpecs(),
+        builtinToolFiltering: this.builtinToolFiltering,
         runtimeContext: input.runtimeContext,
         abortSignal: input.abortSignal,
         telemetry: this.settings.telemetry,
@@ -2704,7 +2838,9 @@ var HarnessAgent = class {
       prompt: input.turnInput.prompt,
       instructions: this.settings.instructions,
       tools: this.tools,
+      activeTools: this.activeUserTools,
       toolSpecs: this._toToolSpecs(),
+      builtinToolFiltering: this.builtinToolFiltering,
       runtimeContext: input.runtimeContext,
       abortSignal: input.abortSignal,
       telemetry: this.settings.telemetry
@@ -2771,7 +2907,7 @@ var HarnessAgent = class {
   _toToolSpecs() {
     const specs = [];
     for (const [name3, tool] of Object.entries(
-      this.userTools
+      this.activeUserTools
     )) {
       const t = tool;
       let inputSchema;