@ai-sdk/harness 1.0.99 → 1.0.101

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @ai-sdk/harness
 
+## 1.0.101
+
+### Patch Changes
+
+- 951c54d: feat(harness): support `askUserQuestions` tool including support for normalization across harness adapters
+- Updated dependencies [a51cc94]
+- Updated dependencies [d1904d3]
+- Updated dependencies [84e5a79]
+- Updated dependencies [a8e8ad0]
+  - ai@7.0.92
+
+## 1.0.100
+
+### Patch Changes
+
+- 0c37bf0: fix(harness): avoid warning about lack of credential brokering support when `credentialForwarding` callback is used to replace all credentials with ephemeral fake secrets
+- Updated dependencies [802af1e]
+  - ai@7.0.91
+
 ## 1.0.99
 
 ### Patch Changes

package/agent/index.ts

@@ -28,14 +28,8 @@ export type {
   HarnessAgentToolSpec,
 } from '../src/agent/harness-agent-types';
 export { HarnessAgentSession } from '../src/agent/harness-agent-session';
-export {
-  collectHarnessAgentToolApprovalContinuations,
-  type HarnessAgentToolApprovalContinuation,
-} from '../src/agent/harness-agent-tool-approval-continuation';
-export {
-  collectHarnessAgentToolResultContinuations,
-  type HarnessAgentToolResultContinuation,
-} from '../src/agent/harness-agent-tool-result-continuation';
+export { collectHarnessAgentToolApprovalContinuations } from '../src/agent/harness-agent-tool-approval-continuation';
+export { collectHarnessAgentToolResultContinuations } from '../src/agent/harness-agent-tool-result-continuation';
 export {
   prepareHarnessSandboxTemplate,
   prewarmHarness,

package/dist/agent/index.d.ts

@@ -1,5 +1,5 @@
 import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
-import { Experimental_SandboxSession, UserModelMessage, ToolSet, FlexibleSchema, Tool, Context, MaybePromiseLike, Arrayable, ToolApprovalResponse, ModelMessage } from '@ai-sdk/provider-utils';
+import { Experimental_SandboxSession, UserModelMessage, ToolResultPart, ProviderOptions, ToolSet, FlexibleSchema, Tool, Context, MaybePromiseLike, Arrayable, ToolApprovalResponse, ModelMessage } from '@ai-sdk/provider-utils';
 import { OutputInterface, AgentCallParameters, Prompt, StopCondition, ToolApprovalStatus, TelemetryOptions, ActiveTools, StreamTextResult, Agent, GenerateTextResult, AgentStreamParameters, Telemetry } from 'ai';
 import { z } from 'zod/v4';
 import { JSONSchema7, JSONValue, LanguageModelV4StreamPart, LanguageModelV4ToolCall, LanguageModelV4ToolApprovalRequest, LanguageModelV4ToolResult, LanguageModelV4FinishReason, LanguageModelV4Usage, AISDKError } from '@ai-sdk/provider';
@@ -347,6 +347,7 @@ type HarnessV1PromptControl = {
         toolCallId: string;
         output: unknown;
         isError?: boolean;
+        toolResult?: ToolResultPart;
     }): PromiseLike<void>;
     /**
      * Respond to a `tool-approval-request` the adapter emitted.
@@ -465,6 +466,7 @@ type HarnessV1PendingToolResult = {
     readonly toolCallId: string;
     readonly toolName: string;
     readonly input: string;
+    readonly providerOptions?: ProviderOptions;
 };
 /**
  * Framework-owned settings captured when a turn begins. The same settings are
@@ -1015,6 +1017,40 @@ declare const HARNESS_V1_BUILTIN_TOOLS: {
     readonly webSearch: Tool<{
         query: string;
     }, unknown, _ai_sdk_provider_utils.Context>;
+    readonly askUserQuestions: _ai_sdk_provider_utils.FunctionTool<{
+        allowPartialAnswers: boolean;
+        questions: {
+            id: string;
+            question: string;
+            header?: string | undefined;
+            options?: {
+                id: string;
+                label: string;
+                description?: string | undefined;
+                preview?: string | undefined;
+            }[] | undefined;
+            allowMultiple?: boolean | undefined;
+            allowFreeForm?: boolean | {
+                secret: boolean;
+            } | undefined;
+        }[];
+    }, {
+        action: "answered";
+        answers: Record<string, {
+            optionIds: string[];
+            freeform?: string | undefined;
+        }>;
+    } | {
+        action: "partially-answered";
+        answers: Record<string, {
+            optionIds: string[];
+            freeform?: string | undefined;
+        }>;
+    } | {
+        action: "declined";
+    } | {
+        action: "cancelled";
+    }>;
 };
 type HarnessV1BuiltinToolName = keyof typeof HARNESS_V1_BUILTIN_TOOLS;
 type HarnessV1BuiltinToolUseKind = 'readonly' | 'edit' | 'bash';
@@ -1391,44 +1427,6 @@ type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAge
     readonly onLog?: (event: HarnessDiagnostic) => void;
 } & HarnessAgentToolFilteringSettings<HarnessAllTools<THarness, TUserTools>>;
 
-type HarnessAgentToolApprovalContinuation = {
-    readonly approvalResponse: ToolApprovalResponse;
-    readonly toolCall: {
-        readonly type: 'tool-call';
-        readonly toolCallId: string;
-        readonly toolName: string;
-        readonly input: unknown;
-        readonly providerExecuted?: boolean;
-    };
-};
-/**
- * Extract approval decisions that should continue a suspended harness turn.
- *
- * AI SDK clients send approval decisions as a trailing `role: "tool"` message
- * containing `tool-approval-response` parts. The response only carries the
- * approval id, so the harness has to recover the matching approval request
- * locally to find the original tool call before it can resume the paused turn.
- * Responses that already have a tool result are ignored, because those
- * approvals were already consumed by a prior continuation.
- */
-declare function collectHarnessAgentToolApprovalContinuations(input: {
-    messages: readonly ModelMessage[];
-}): readonly HarnessAgentToolApprovalContinuation[];
-
-type HarnessAgentToolResultContinuation = {
-    readonly toolCallId: string;
-    readonly output: unknown;
-    readonly isError?: boolean;
-};
-/**
- * Extract client-provided tool results from the trailing tool message and
- * convert AI SDK model-output wrappers back into values a harness runtime can
- * return from its pending host-tool invocation.
- */
-declare function collectHarnessAgentToolResultContinuations(input: {
-    messages: readonly ModelMessage[];
-}): readonly HarnessAgentToolResultContinuation[];
-
 type HarnessAgentTurnResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface> = {
     result: StreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
     done: Promise<void>;
@@ -1519,8 +1517,8 @@ declare class HarnessAgentSession {
         output: OUTPUT | undefined;
         telemetry: TelemetryOptions | undefined;
         stopConditions: ReadonlyArray<StopCondition<TOOLS, RUNTIME_CONTEXT>>;
-        toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[] | undefined;
-        toolResultContinuations?: readonly HarnessAgentToolResultContinuation[] | undefined;
+        toolApprovalContinuations?: readonly ToolApprovalResponse[] | undefined;
+        toolResultContinuations?: readonly ToolResultPart[] | undefined;
     }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
     /**
      * Ask the underlying runtime to compact its context. The runtime performs
@@ -1703,8 +1701,8 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
      */
     continueGenerate(options: {
         session: HarnessAgentSession;
-        toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
-        toolResultContinuations?: readonly HarnessAgentToolResultContinuation[];
+        toolApprovalContinuations?: readonly ToolApprovalResponse[];
+        toolResultContinuations?: readonly ToolResultPart[];
         abortSignal?: AbortSignal;
     }): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
     /**
@@ -1717,8 +1715,8 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
      */
     continueStream(options: {
         session: HarnessAgentSession;
-        toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
-        toolResultContinuations?: readonly HarnessAgentToolResultContinuation[];
+        toolApprovalContinuations?: readonly ToolApprovalResponse[];
+        toolResultContinuations?: readonly ToolResultPart[];
         abortSignal?: AbortSignal;
     }): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
     /**
@@ -1745,6 +1743,27 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
     private _resolveResponseFormat;
 }
 
+/**
+ * Extract approval decisions that should continue a suspended harness turn.
+ *
+ * AI SDK clients send approval decisions as a trailing `role: "tool"` message
+ * containing `tool-approval-response` parts. The response only carries the
+ * approval id, so the harness has to recover the matching approval request
+ * locally to find the original tool call before it can resume the paused turn.
+ * Responses that already have a tool result are ignored, because those
+ * approvals were already consumed by a prior continuation.
+ */
+declare function collectHarnessAgentToolApprovalContinuations(input: {
+    messages: readonly ModelMessage[];
+}): readonly ToolApprovalResponse[];
+
+/**
+ * Extract client-provided tool results from the trailing tool message.
+ */
+declare function collectHarnessAgentToolResultContinuations(input: {
+    messages: readonly ModelMessage[];
+}): readonly ToolResultPart[];
+
 type SandboxBootstrapSettings = Omit<HarnessAgentSandboxConfig, 'onSession'>;
 /**
  * Prepare a harness's sandbox template without running an agent. Idempotent: if
@@ -1902,4 +1921,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 HarnessAgentPendingToolResult, 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 HarnessAgentToolResultContinuation, type HarnessAgentToolSpec, type HarnessAllTools, HarnessCapabilityUnsupportedError, type HarnessDebugConfig, type HarnessDebugLevel, type HarnessDiagnostic, type HarnessDiagnosticConsumer, HarnessError, HarnessSandboxAuthenticationError, type PrepareSandboxForHarnessResult, type TraceTreeReporterOptions, collectHarnessAgentToolApprovalContinuations, collectHarnessAgentToolResultContinuations, createFileReporter, createTraceTreeReporter, getHarnessErrorMessage, 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 HarnessAgentPendingToolResult, type HarnessAgentPermissionMode, type HarnessAgentPrompt, type HarnessAgentPromptControl, type HarnessAgentPromptTurnOptions, type HarnessAgentResumeSessionState, type HarnessAgentSandboxConfig, HarnessAgentSession, type HarnessAgentSettings, type HarnessAgentSkill, type HarnessAgentStartOptions, type HarnessAgentStreamPart, type HarnessAgentToolApprovalConfiguration, type HarnessAgentToolSpec, type HarnessAllTools, HarnessCapabilityUnsupportedError, type HarnessDebugConfig, type HarnessDebugLevel, type HarnessDiagnostic, type HarnessDiagnosticConsumer, HarnessError, HarnessSandboxAuthenticationError, type PrepareSandboxForHarnessResult, type TraceTreeReporterOptions, collectHarnessAgentToolApprovalContinuations, collectHarnessAgentToolResultContinuations, createFileReporter, createTraceTreeReporter, getHarnessErrorMessage, prepareHarnessSandboxTemplate, prepareSandboxForHarness, prewarmHarness };

package/dist/agent/index.js

@@ -1556,6 +1556,25 @@ function pinSandboxChannelEventCheckpoint(event) {
 }
 
 // src/agent/internal/run-prompt.ts
+function unwrapToolResultOutput(toolResult) {
+  switch (toolResult.output.type) {
+    case "text":
+    case "json":
+      return { output: toolResult.output.value };
+    case "error-text":
+    case "error-json":
+      return { output: toolResult.output.value, isError: true };
+    case "execution-denied":
+      return {
+        output: {
+          type: toolResult.output.type,
+          reason: toolResult.output.reason
+        }
+      };
+    case "content":
+      return { output: toolResult.output };
+  }
+}
 function runPrompt(input) {
   var _a4, _b4, _c, _d, _e, _f, _g;
   const result = new HarnessStreamTextResult({
@@ -1680,7 +1699,7 @@ function runPrompt(input) {
     );
     const continuationsByApprovalId = new Map(
       ((_b5 = input.toolApprovalContinuations) != null ? _b5 : []).map((continuation) => [
-        continuation.approvalResponse.approvalId,
+        continuation.approvalId,
         continuation
       ])
     );
@@ -1812,13 +1831,13 @@ function runPrompt(input) {
         ...input2.providerExecuted !== void 0 ? { providerExecuted: input2.providerExecuted } : {}
       });
     };
-    const enqueueApprovalResponse = (approval, continuation) => {
+    const enqueueApprovalResponse = (approval, continuation, toolCall) => {
       result.enqueueContinuation({
         type: "tool-approval-response",
         approvalId: approval.approvalId,
-        toolCall: continuation.toolCall,
-        approved: continuation.approvalResponse.approved,
-        ...continuation.approvalResponse.reason !== void 0 ? { reason: continuation.approvalResponse.reason } : {},
+        toolCall,
+        approved: continuation.approved,
+        ...continuation.reason !== void 0 ? { reason: continuation.reason } : {},
         ...approval.providerExecuted !== void 0 ? { providerExecuted: approval.providerExecuted } : {}
       });
     };
@@ -1827,20 +1846,27 @@ function runPrompt(input) {
       const pendingResult = (_a6 = pendingResultsByToolCallId.get(options.toolCall.toolCallId)) != null ? _a6 : {
         toolCallId: options.toolCall.toolCallId,
         toolName: options.toolCall.toolName,
-        input: options.toolCall.input
+        input: options.toolCall.input,
+        ...options.toolCall.providerMetadata !== void 0 ? { providerOptions: options.toolCall.providerMetadata } : {}
       };
       pendingResultsByToolCallId.set(pendingResult.toolCallId, pendingResult);
       onPendingToolResult(pendingResult);
       return pendingResult;
     };
     const processPendingToolResultContinuation = async (pendingResult, continuation) => {
+      const result2 = unwrapToolResultOutput(continuation);
       onToolResultSettled(pendingResult.toolCallId);
       pendingResultsByToolCallId.delete(pendingResult.toolCallId);
       settledHostToolCallIds.add(pendingResult.toolCallId);
       await control.submitToolResult({
         toolCallId: pendingResult.toolCallId,
-        output: continuation.output,
-        isError: continuation.isError
+        output: result2.output,
+        isError: result2.isError,
+        toolResult: {
+          ...continuation,
+          toolName: pendingResult.toolName,
+          ...continuation.providerOptions == null && pendingResult.providerOptions != null ? { providerOptions: pendingResult.providerOptions } : {}
+        }
       });
     };
     const enqueueHostToolOutcome = (options) => {
@@ -1873,7 +1899,23 @@ function runPrompt(input) {
     };
     const processPendingApprovalContinuation = async (approval, continuation) => {
       var _a6;
-      enqueueApprovalResponse(approval, continuation);
+      const rawToolCall = (_a6 = rawToolCallsByToolCallId.get(approval.toolCallId)) != null ? _a6 : {
+        type: "tool-call",
+        toolCallId: approval.toolCallId,
+        toolName: approval.toolName,
+        input: approval.input,
+        providerExecuted: approval.providerExecuted,
+        nativeName: approval.nativeName
+      };
+      const parsedInput = await safeParseJSON2({ text: rawToolCall.input });
+      const toolCall = {
+        type: "tool-call",
+        toolCallId: rawToolCall.toolCallId,
+        toolName: rawToolCall.toolName,
+        input: parsedInput.success ? parsedInput.value : rawToolCall.input,
+        ...rawToolCall.providerExecuted !== void 0 ? { providerExecuted: rawToolCall.providerExecuted } : {}
+      };
+      enqueueApprovalResponse(approval, continuation, toolCall);
       onToolApprovalSettled(approval.approvalId);
       pendingApprovalsByApprovalId.delete(approval.approvalId);
       pendingApprovalsByToolCallId.delete(approval.toolCallId);
@@ -1886,28 +1928,22 @@ function runPrompt(input) {
         }
         await control.submitToolApproval({
           approvalId: approval.approvalId,
-          approved: continuation.approvalResponse.approved,
-          reason: continuation.approvalResponse.reason
+          approved: continuation.approved,
+          reason: continuation.reason
         });
         return "continued";
       }
       settledHostToolCallIds.add(approval.toolCallId);
-      if (!continuation.approvalResponse.approved) {
+      if (!continuation.approved) {
         await control.submitToolResult({
           toolCallId: approval.toolCallId,
           output: {
             type: "execution-denied",
-            reason: continuation.approvalResponse.reason
+            reason: continuation.reason
           }
         });
         return "continued";
       }
-      const rawToolCall = (_a6 = rawToolCallsByToolCallId.get(approval.toolCallId)) != null ? _a6 : {
-        type: "tool-call",
-        toolCallId: approval.toolCallId,
-        toolName: approval.toolName,
-        input: approval.input
-      };
       await telemetry.start(input.model);
       await telemetry.toolStart({
         toolCallId: rawToolCall.toolCallId,
@@ -1947,7 +1983,7 @@ function runPrompt(input) {
         return "awaiting-tool-result";
       }
       enqueueHostToolOutcome({
-        toolCall: continuation.toolCall,
+        toolCall,
         outcome: execution.outcome
       });
       await telemetry.toolEnd(rawToolCall.toolCallId, execution.outcome);
@@ -2200,7 +2236,11 @@ 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 isClientExecutedBuiltin = toolCall.toolName === "askUserQuestions" && Object.prototype.hasOwnProperty.call(
+            input.harness.builtinTools,
+            toolCall.toolName
+          );
+          if (!isClientExecutedBuiltin && !hasTool({ tools: activeTools, toolName: toolCall.toolName })) {
             const output = {
               type: "execution-denied",
               reason: getHarnessV1BuiltinToolFilteringDenialReason({
@@ -2214,6 +2254,15 @@ function runPrompt(input) {
             await telemetry.toolEnd(toolCall.toolCallId, { ok: true, output });
             continue;
           }
+          if (isClientExecutedBuiltin) {
+            recordPendingToolResult({ toolCall });
+            if (expectedStepToolCallCount != null && observedStepToolCallCount < expectedStepToolCallCount) {
+              pauseAfterStepToolCalls = true;
+              continue;
+            }
+            await finishForHostInputPause({ completeCurrentStep: true });
+            return;
+          }
           const customToolApprovalDecision = resolveCustomToolApproval({
             toolName: toolCall.toolName,
             toolApproval: input.toolApproval
@@ -3030,7 +3079,7 @@ var HarnessAgentSession = class {
 function collectHarnessAgentToolApprovalContinuations(input) {
   const lastMessage = input.messages.at(-1);
   if ((lastMessage == null ? void 0 : lastMessage.role) !== "tool") return [];
-  const toolCallsByToolCallId = /* @__PURE__ */ new Map();
+  const toolCallIds = /* @__PURE__ */ new Set();
   const approvalRequestsByApprovalId = /* @__PURE__ */ new Map();
   for (const message of input.messages) {
     if (message.role !== "assistant" || typeof message.content === "string") {
@@ -3038,13 +3087,7 @@ function collectHarnessAgentToolApprovalContinuations(input) {
     }
     for (const part of message.content) {
       if (part.type === "tool-call") {
-        toolCallsByToolCallId.set(part.toolCallId, {
-          type: "tool-call",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          input: part.input,
-          ...part.providerExecuted !== void 0 ? { providerExecuted: part.providerExecuted } : {}
-        });
+        toolCallIds.add(part.toolCallId);
       } else if (part.type === "tool-approval-request") {
         approvalRequestsByApprovalId.set(part.approvalId, part);
       }
@@ -3066,16 +3109,12 @@ function collectHarnessAgentToolApprovalContinuations(input) {
       });
     }
     if (toolResultIds.has(approvalRequest.toolCallId)) continue;
-    const toolCall = toolCallsByToolCallId.get(approvalRequest.toolCallId);
-    if (toolCall == null) {
+    if (!toolCallIds.has(approvalRequest.toolCallId)) {
       throw new HarnessError({
         message: `Tool approval request '${approvalRequest.approvalId}' references unknown tool call '${approvalRequest.toolCallId}'.`
       });
     }
-    continuations.push({
-      approvalResponse: part,
-      toolCall
-    });
+    continuations.push(part);
   }
   return continuations;
 }
@@ -3084,42 +3123,7 @@ function collectHarnessAgentToolApprovalContinuations(input) {
 function collectHarnessAgentToolResultContinuations(input) {
   const lastMessage = input.messages.at(-1);
   if ((lastMessage == null ? void 0 : lastMessage.role) !== "tool") return [];
-  return lastMessage.content.filter((part) => part.type === "tool-result").map(
-    (part) => toToolResultContinuation({
-      toolCallId: part.toolCallId,
-      output: part.output
-    })
-  );
-}
-function toToolResultContinuation(input) {
-  switch (input.output.type) {
-    case "text":
-    case "json":
-      return {
-        toolCallId: input.toolCallId,
-        output: input.output.value
-      };
-    case "error-text":
-    case "error-json":
-      return {
-        toolCallId: input.toolCallId,
-        output: input.output.value,
-        isError: true
-      };
-    case "execution-denied":
-      return {
-        toolCallId: input.toolCallId,
-        output: {
-          type: input.output.type,
-          reason: input.output.reason
-        }
-      };
-    case "content":
-      return {
-        toolCallId: input.toolCallId,
-        output: input.output
-      };
-  }
+  return lastMessage.content.filter((part) => part.type === "tool-result");
 }
 
 // src/agent/internal/bootstrap-recipe.ts
@@ -3582,6 +3586,10 @@ var HarnessAgent = class {
     this.sandboxConfig = sandboxConfig;
     this.id = settings.id;
     const userTools = (_a4 = settings.tools) != null ? _a4 : {};
+    assertNoReservedQuestionTool({
+      harness: settings.harness,
+      userTools
+    });
     this.permissionMode = resolvePermissionMode({
       permissionMode: settings.permissionMode
     });
@@ -4059,6 +4067,10 @@ var HarnessAgent = class {
   _prepareTurnSettings(options) {
     var _a4, _b4;
     const userTools = (_a4 = options.tools) != null ? _a4 : {};
+    assertNoReservedQuestionTool({
+      harness: this.settings.harness,
+      userTools
+    });
     const tools = {
       ...this.settings.harness.builtinTools,
       ...userTools
@@ -4127,6 +4139,16 @@ var HarnessAgent = class {
     };
   }
 };
+function assertNoReservedQuestionTool(input) {
+  if (Object.prototype.hasOwnProperty.call(
+    input.harness.builtinTools,
+    "askUserQuestions"
+  ) && Object.prototype.hasOwnProperty.call(input.userTools, "askUserQuestions")) {
+    throw new Error(
+      "HarnessAgent tool name 'askUserQuestions' is reserved for harness question requests."
+    );
+  }
+}
 var HarnessGenerateTextResult = class {
   constructor(options) {
     this.steps = options.steps;