@ai-sdk/harness 1.0.118 → 1.0.120

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @ai-sdk/harness
 
+## 1.0.120
+
+### Patch Changes
+
+- ai@7.0.110
+
+## 1.0.119
+
+### Patch Changes
+
+- 125f493: fix(harness): forward validated `toolsContext` to host-executed tools in alignment with `ToolLoopAgent`
+- Updated dependencies [0343bb1]
+- Updated dependencies [2b105fa]
+- Updated dependencies [125f493]
+  - ai@7.0.109
+
 ## 1.0.118
 
 ### Patch Changes

package/README.md

@@ -99,112 +99,8 @@ const agent = new HarnessAgent({
 });
 ```
 
-Use `session.detach()` to park a bridge-backed session for later attach, `session.stop()` to save state and stop the sandbox, or `session.destroy()` to clean up without keeping resume state. Bridge-backed adapters such as Claude Code, Codex, OpenCode, and DeepAgents require a network sandbox session that exposes ports — `@ai-sdk/sandbox-vercel` is the supported choice today. `@ai-sdk/sandbox-just-bash` is suitable only for host-runtime or otherwise non-bridge flows, such as Pi.
+## Documentation
 
-Set `model` on `HarnessAgent` to select the model used when the harness session
-starts. Model identifiers are harness-specific, so `model` accepts any string.
-
-`sandbox` is an optional `HarnessV1SandboxProvider`. When omitted, pass a `HarnessV1NetworkSandboxSession` to every `agent.createSession({ sandboxSession })` call. Use `sandboxConfig` for agent specific sandbox configuration that works independently from the sandbox provider that is used:
-
-- Use `sandboxConfig.onSession` to prepare the acquired sandbox before the harness adapter starts. The hook runs for fresh and resumed sessions, so keep it idempotent.
-- Use `sandboxConfig.onBootstrap` for expensive sandbox setup that should be baked into a reusable snapshot, such as installing tools or cloning a large repository. Provide `sandboxConfig.bootstrapHash` with it and change that value whenever the bootstrap output should invalidate the cached snapshot.
-- Use `sandboxConfig.workDir` to set a stable working directory for the agent, relative to the sandbox's default working directory; otherwise regular sessions use the existing `<harnessId>-<sessionId>` directory. In that case, the `onBootstrap` callback receives the sandbox's default working directory.
-
-Use `prepareHarnessSandboxTemplate()` to create or refresh the sandbox provider's
-own reusable template for one harness before serving traffic. This is the
-replacement for `prewarmHarness()`, which remains as a deprecated alias.
-
-Use `prepareSandboxForHarness()` when you own an existing sandbox and want to
-prepare it before creating your own snapshot. It applies the selected harness
-bootstrap recipes and `sandboxConfig.onBootstrap`, returns the computed
-preparation identity and per-harness recipe identities, and leaves snapshotting
-or stopping the sandbox to your code. Later, create a sandbox from that snapshot
-and pass the native sandbox object to `createVercelSandbox({ sandbox })` for the
-`HarnessAgent`. When several bridge-backed harnesses share a caller-provided
-sandbox, create that sandbox with one exposed port for each harness. Then pass
-each harness's assigned port to that harness's `create*` function.
-
-### Available harnesses
-
-See the [harness adapters documentation](https://ai-sdk.dev/v7/docs/ai-sdk-harnesses/harness-adapters).
-
-## Implementing a harness
-
-Implement the `HarnessV1` factory and a `HarnessV1Session` whose `doPromptTurn` emits events; the agent surface, streaming, tool execution, and multi-turn state are handled for you. Read `startOpts.model` for the consumer-selected model and `startOpts.sandboxSession` for the selected network sandbox session. The harness layer stops or destroys sessions it acquires from the provider, while a session passed to `agent.createSession({ sandboxSession })` remains caller-owned. Call `sandboxSession.restricted()` for the tool-safe file-IO/exec/spawn surface.
-
-Each prompt and continuation receives an optional `responseFormat`. JSON
-formats carry a caller-provided JSON Schema plus optional name and description;
-the adapter must enforce the schema and emit the resulting JSON through normal
-text parts. If the runtime cannot honor the format, throw
-`HarnessCapabilityUnsupportedError` before starting the turn.
-
-Bootstrap recipe paths may be absolute or relative. Relative `bootstrapDir` and
-file paths are resolved against `sandboxSession.defaultWorkingDirectory`.
-The framework creates `bootstrapDir` before writing files, and bootstrap
-commands always run from that directory. Prefer a relative directory such as
-`.harness-bootstrap/my-harness` so bootstrap assets are kept with the sandbox's
-snapshot-persistent working tree.
-
-```ts
-import type { HarnessV1, HarnessV1Session } from '@ai-sdk/harness';
-
-export function myHarness(): HarnessV1 {
-  return {
-    specificationVersion: 'harness-v1',
-    harnessId: 'my-harness',
-    builtinTools: {},
-    doStart: async startOpts => {
-      const usage = {
-        inputTokens: { total: 0, noCache: 0 },
-        outputTokens: { total: 0, text: 0 },
-      };
-      const resumeState = {
-        type: 'resume-session' as const,
-        harnessId: 'my-harness',
-        specificationVersion: 'harness-v1' as const,
-        data: {},
-      };
-      const continueState = {
-        type: 'continue-turn' as const,
-        harnessId: 'my-harness',
-        specificationVersion: 'harness-v1' as const,
-        data: {},
-      };
-      const session: HarnessV1Session = {
-        sessionId: startOpts.sessionId,
-        isResume:
-          startOpts.resumeFrom != null || startOpts.continueFrom != null,
-        doPromptTurn: async promptOpts => {
-          const done = Promise.resolve().then(() => {
-            promptOpts.emit({ type: 'text-start', id: 't' });
-            promptOpts.emit({ type: 'text-delta', id: 't', delta: 'Hello.' });
-            promptOpts.emit({ type: 'text-end', id: 't' });
-            promptOpts.emit({
-              type: 'finish',
-              finishReason: { unified: 'stop', raw: 'stop' },
-              totalUsage: usage,
-            });
-          });
-          return { submitToolResult: async () => {}, done };
-        },
-        doContinueTurn: async continueOpts => {
-          const done = Promise.resolve().then(() => {
-            continueOpts.emit({
-              type: 'finish',
-              finishReason: { unified: 'stop', raw: 'stop' },
-              totalUsage: usage,
-            });
-          });
-          return { submitToolResult: async () => {}, done };
-        },
-        doCompact: async () => {},
-        doDetach: async () => resumeState,
-        doStop: async () => resumeState,
-        doDestroy: async () => {},
-        doSuspendTurn: async () => continueState,
-      };
-      return session;
-    },
-  };
-}
-```
+- [Detailed usage documentation](https://ai-sdk.dev/docs/ai-sdk-harnesses)
+- [Harness abstraction architecture](https://github.com/vercel/ai/blob/main/architecture/harness-abstraction.md)
+- [Sandbox abstraction architecture](https://github.com/vercel/ai/blob/main/architecture/sandbox-abstraction.md)

package/dist/agent/index.d.ts

@@ -1,5 +1,6 @@
 import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
-import { Experimental_SandboxSession, UserModelMessage, ToolResultPart, ProviderOptions, ToolSet, FlexibleSchema, Tool, Context, SystemModelMessage, MaybePromiseLike, Arrayable, ToolApprovalResponse, ModelMessage } from '@ai-sdk/provider-utils';
+import { Experimental_SandboxSession, UserModelMessage, ToolResultPart, ProviderOptions, ToolSet, FlexibleSchema, Tool, Context, InferToolSetContext, SystemModelMessage, MaybePromiseLike, Arrayable, ToolApprovalResponse, ModelMessage } from '@ai-sdk/provider-utils';
+import { ToolsContextSettings } from 'ai/internal';
 import { OutputInterface, AgentCallParameters, Prompt, StopCondition, GenerateTextOnStartCallback, GenerateTextOnStepStartCallback, OnLanguageModelCallStartCallback, OnLanguageModelCallEndCallback, OnToolExecutionStartCallback, OnToolExecutionEndCallback, GenerateTextOnStepEndCallback, GenerateTextOnEndCallback, 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';
@@ -1344,6 +1345,12 @@ type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAge
      * declare a tool with the same name as a builtin to override.
      */
     readonly tools?: TUserTools;
+    /**
+     * Per-tool context passed to host-executed tools. Each entry is validated
+     * against the matching tool's `contextSchema` before execution.
+     * `prepareCall` can replace it for each new turn.
+     */
+    readonly toolsContext?: InferToolSetContext<TUserTools>;
     /**
      * Skills made available to the underlying runtime. Each adapter decides how
      * to surface skills. `prepareCall` can replace them between completed turns.
@@ -1383,7 +1390,11 @@ type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAge
      * })
      * ```
      */
-    readonly prepareCall?: (options: Omit<AgentCallParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT>, 'abortSignal' | 'timeout' | 'onStart' | 'experimental_onStart' | 'onStepStart' | 'experimental_onStepStart' | 'onToolExecutionStart' | 'experimental_onToolCallStart' | 'onToolExecutionEnd' | 'experimental_onToolCallFinish' | 'onStepEnd' | 'onStepFinish' | 'onEnd' | 'onFinish' | 'experimental_sandbox'> & Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools'>) => MaybePromiseLike<Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools'> & Omit<Prompt, 'system' | 'instructions' | 'allowSystemInMessages'>>;
+    readonly prepareCall?: (options: Omit<AgentCallParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT>, 'abortSignal' | 'timeout' | 'onStart' | 'experimental_onStart' | 'onStepStart' | 'experimental_onStepStart' | 'onToolExecutionStart' | 'experimental_onToolCallStart' | 'onToolExecutionEnd' | 'experimental_onToolCallFinish' | 'onStepEnd' | 'onStepFinish' | 'onEnd' | 'onFinish' | 'experimental_sandbox'> & Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools'> & {
+        toolsContext: InferToolSetContext<TUserTools>;
+    }) => MaybePromiseLike<Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools'> & {
+        toolsContext: InferToolSetContext<TUserTools>;
+    } & Omit<Prompt, 'system' | 'instructions' | 'allowSystemInMessages'>>;
     /**
      * Optional specification for generating typed output. The same output
      * requirement is active for every turn run by this agent.
@@ -1478,7 +1489,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>>;
+} & ToolsContextSettings<TUserTools> & HarnessAgentToolFilteringSettings<HarnessAllTools<THarness, TUserTools>>;
 
 type HarnessAgentLifecycleCallbacks<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface> = {
     onStart?: GenerateTextOnStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
@@ -1533,6 +1544,7 @@ declare class HarnessAgentSession {
     private suspendedTurnState;
     private activeTurnSettings;
     private persistedTurnSettings;
+    private readonly resumedToolsContext;
     /**
      * Whether this session was created from `resumeFrom` or `continueFrom`.
      * Captured at construction so it survives lifecycle cleanup.
@@ -1549,6 +1561,7 @@ declare class HarnessAgentSession {
         pendingToolApprovals?: readonly HarnessAgentPendingToolApproval[];
         pendingToolResults?: readonly HarnessAgentPendingToolResult[];
         turnSettings?: HarnessV1TurnSettings;
+        resumedToolsContext?: Record<string, Context | undefined>;
         turnState?: HarnessAgentTurnState;
     });
     hasUnfinishedTurn(): boolean;
@@ -1558,6 +1571,7 @@ declare class HarnessAgentSession {
         skills: ReadonlyArray<HarnessV1Skill>;
         instructions: string | undefined;
         tools: TOOLS;
+        toolsContext: InferToolSetContext<TOOLS>;
         activeTools: ToolSet;
         toolSpecs: HarnessAgentToolSpec[];
         builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
@@ -1574,6 +1588,7 @@ declare class HarnessAgentSession {
         skills: ReadonlyArray<HarnessV1Skill>;
         instructions: string | undefined;
         tools: TOOLS;
+        toolsContext: InferToolSetContext<TOOLS>;
         activeTools: ToolSet;
         toolSpecs: HarnessAgentToolSpec[];
         builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
@@ -1756,6 +1771,13 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
          * handing it to the adapter.
          */
         continueFrom?: HarnessAgentContinueTurnState;
+        /**
+         * Rebinds host-only tool context for an unfinished turn resumed with
+         * `continueFrom` (directly or through `resumeFrom`). Tool context is not
+         * serialized into lifecycle state because it may contain credentials or
+         * non-serializable host objects.
+         */
+        toolsContext?: ToolsContextSettings<TUserTools>['toolsContext'];
         /**
          * Existing sandbox session to run the harness in. When provided, the
          * caller retains ownership of the sandbox lifecycle.

package/dist/agent/index.js

@@ -164,7 +164,11 @@ import {
 import {
   getErrorMessage
 } from "@ai-sdk/provider";
-import { asLanguageModelUsage as asLanguageModelUsage2, parseToolCall } from "ai/internal";
+import {
+  asLanguageModelUsage as asLanguageModelUsage2,
+  parseToolCall,
+  validateToolContext
+} from "ai/internal";
 
 // src/agent/internal/harness-stream-text-result.ts
 import {
@@ -851,6 +855,11 @@ function notSupportedYet(feature) {
   );
 }
 
+// src/agent/internal/get-own.ts
+function getOwn(obj, key) {
+  return obj != null && Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : void 0;
+}
+
 // src/agent/internal/translate-stream-part.ts
 import { generateId } from "@ai-sdk/provider-utils";
 function translateStreamPart(event, options = {}) {
@@ -1525,29 +1534,29 @@ function unwrapToolResultOutput(toolResult) {
   }
 }
 function runPrompt(input) {
-  var _a4, _b4, _c, _d, _e, _f, _g, _h, _i;
+  var _a4, _b4, _c, _d, _e, _f, _g, _h, _i, _j;
   const callId = generateId2();
-  const toolsContext = {};
+  const toolsContext = (_a4 = input.toolsContext) != null ? _a4 : {};
   const result = new HarnessStreamTextResult({
     tools: input.tools,
     runtimeContext: input.runtimeContext,
     toolsContext,
     harnessId: input.harness.harnessId,
     callId,
-    modelId: (_a4 = input.model) != null ? _a4 : "",
+    modelId: (_b4 = input.model) != null ? _b4 : "",
     output: input.output
   });
-  const pendingToolApprovals = (_b4 = input.pendingToolApprovals) != null ? _b4 : [];
-  const pendingToolResults = (_c = input.pendingToolResults) != null ? _c : [];
-  const onPendingToolApproval = (_d = input.onPendingToolApproval) != null ? _d : (() => {
+  const pendingToolApprovals = (_c = input.pendingToolApprovals) != null ? _c : [];
+  const pendingToolResults = (_d = input.pendingToolResults) != null ? _d : [];
+  const onPendingToolApproval = (_e = input.onPendingToolApproval) != null ? _e : (() => {
   });
-  const onToolApprovalSettled = (_e = input.onToolApprovalSettled) != null ? _e : (() => {
+  const onToolApprovalSettled = (_f = input.onToolApprovalSettled) != null ? _f : (() => {
   });
-  const onPendingToolResult = (_f = input.onPendingToolResult) != null ? _f : (() => {
+  const onPendingToolResult = (_g = input.onPendingToolResult) != null ? _g : (() => {
   });
-  const onToolResultSettled = (_g = input.onToolResultSettled) != null ? _g : (() => {
+  const onToolResultSettled = (_h = input.onToolResultSettled) != null ? _h : (() => {
   });
-  const activeTools = (_h = input.activeTools) != null ? _h : input.tools;
+  const activeTools = (_i = input.activeTools) != null ? _i : input.tools;
   const activeToolNames = Object.keys(input.tools).filter(
     (toolName) => Object.prototype.hasOwnProperty.call(activeTools, toolName) || Object.prototype.hasOwnProperty.call(
       input.harness.builtinTools,
@@ -1560,7 +1569,7 @@ function runPrompt(input) {
   const lifecycle = createTurnLifecycle({
     callId,
     telemetry: input.telemetry,
-    callbacks: (_i = input.callbacks) != null ? _i : {},
+    callbacks: (_j = input.callbacks) != null ? _j : {},
     harnessId: input.harness.harnessId,
     modelId: input.model,
     instructions: input.instructions,
@@ -1587,7 +1596,7 @@ function runPrompt(input) {
     result.fail(err);
   };
   const done = (async () => {
-    var _a5, _b5, _c2, _d2, _e2, _f2, _g2, _h2, _i2, _j, _k, _l, _m, _n, _o;
+    var _a5, _b5, _c2, _d2, _e2, _f2, _g2, _h2, _i2, _j2, _k, _l, _m, _n, _o;
     let bridge;
     try {
       bridge = await toHarnessStream({
@@ -1972,6 +1981,7 @@ function runPrompt(input) {
       const execution = await maybeExecuteHostTool({
         event: rawToolCall,
         tools: activeTools,
+        toolsContext,
         wrappedExecuteTool: lifecycle.executeTool,
         sandboxSession: input.sandboxSession,
         abortSignal: input.abortSignal,
@@ -2223,7 +2233,7 @@ function runPrompt(input) {
             toolName: toolCall.toolName,
             input: (_i2 = rawToolCall == null ? void 0 : rawToolCall.input) != null ? _i2 : JSON.stringify(toolCall.input),
             kind: "builtin",
-            providerExecuted: (_j = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _j : true,
+            providerExecuted: (_j2 = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _j2 : true,
             ...(rawToolCall == null ? void 0 : rawToolCall.nativeName) !== void 0 ? { nativeName: rawToolCall.nativeName } : {}
           };
           pendingApprovalsByApprovalId.set(
@@ -2418,6 +2428,7 @@ function runPrompt(input) {
               const execution = await maybeExecuteHostTool({
                 event: toolCall,
                 tools: activeTools,
+                toolsContext,
                 wrappedExecuteTool: lifecycle.executeTool,
                 sandboxSession: input.sandboxSession,
                 abortSignal: input.abortSignal,
@@ -2529,6 +2540,21 @@ async function maybeExecuteHostTool(input) {
   if (!isExecutableTool(tool)) return { executed: false };
   const parsed = await safeParseJSON2({ text: input.event.input });
   const args = parsed.success ? parsed.value : input.event.input;
+  let context;
+  try {
+    context = await validateToolContext({
+      toolName: input.event.toolName,
+      context: getOwn(input.toolsContext, input.event.toolName),
+      contextSchema: tool.contextSchema
+    });
+  } catch (err) {
+    await input.submitToolResult({
+      toolCallId: input.event.toolCallId,
+      output: { error: "Tool context validation failed." },
+      isError: true
+    });
+    return { executed: true, outcome: { ok: false, error: err } };
+  }
   try {
     const output = await input.wrappedExecuteTool({
       toolCallId: input.event.toolCallId,
@@ -2541,7 +2567,7 @@ async function maybeExecuteHostTool(input) {
             toolCallId: input.event.toolCallId,
             messages: [],
             abortSignal: input.abortSignal,
-            context: void 0,
+            context,
             experimental_sandbox: input.sandboxSession
           }
         });
@@ -2630,6 +2656,7 @@ var HarnessAgentSession = class {
       this.pendingToolResults.set(pendingResult.toolCallId, pendingResult);
     }
     this.persistedTurnSettings = options.turnSettings;
+    this.resumedToolsContext = options.resumedToolsContext;
     this.turnState = (_d = options.turnState) != null ? _d : this.pendingToolApprovals.size > 0 ? "awaiting-approval" : this.pendingToolResults.size > 0 ? "awaiting-tool-result" : "idle";
     this.isResume = options.underlyingSession.isResume;
   }
@@ -2670,6 +2697,7 @@ var HarnessAgentSession = class {
     this.activeTurnSettings = {
       persisted: this.persistedTurnSettings,
       tools: options.tools,
+      toolsContext: options.toolsContext,
       activeTools: options.activeTools,
       builtinToolFiltering: options.builtinToolFiltering
     };
@@ -2684,6 +2712,7 @@ var HarnessAgentSession = class {
         skills: options.skills,
         instructions: options.instructions,
         tools: options.tools,
+        toolsContext: options.toolsContext,
         activeTools: options.activeTools,
         toolSpecs: options.toolSpecs,
         builtinToolFiltering: options.builtinToolFiltering,
@@ -2743,6 +2772,7 @@ var HarnessAgentSession = class {
       skills: options.skills,
       instructions: options.instructions,
       tools: options.tools,
+      toolsContext: options.toolsContext,
       activeTools: options.activeTools,
       toolSpecs: options.toolSpecs,
       builtinToolFiltering: options.builtinToolFiltering
@@ -2758,6 +2788,7 @@ var HarnessAgentSession = class {
         skills: turnSettings.persisted.skills,
         instructions: turnSettings.persisted.instructions,
         tools: turnSettings.tools,
+        toolsContext: turnSettings.toolsContext,
         activeTools: turnSettings.activeTools,
         toolSpecs: [...turnSettings.persisted.tools],
         builtinToolFiltering: turnSettings.builtinToolFiltering,
@@ -3122,7 +3153,7 @@ var HarnessAgentSession = class {
     this.turnState = "idle";
   }
   resolveActiveTurnSettings(options) {
-    var _a4;
+    var _a4, _b4;
     if (this.activeTurnSettings != null) {
       return this.activeTurnSettings;
     }
@@ -3146,6 +3177,7 @@ var HarnessAgentSession = class {
     this.activeTurnSettings = {
       persisted,
       tools: options.tools,
+      toolsContext: (_b4 = this.resumedToolsContext) != null ? _b4 : options.toolsContext,
       activeTools,
       builtinToolFiltering: options.builtinToolFiltering
     };
@@ -3768,6 +3800,11 @@ var HarnessAgent = class {
       });
     }
     const effectiveContinueFrom = validatedContinueFrom != null ? validatedContinueFrom : validatedResumeFrom == null ? void 0 : validatedResumeFrom.continueFrom;
+    if ((options == null ? void 0 : options.toolsContext) != null && effectiveContinueFrom == null) {
+      throw new Error(
+        "HarnessAgent.createSession: `toolsContext` can only rebind an unfinished turn from `continueFrom` or `resumeFrom`."
+      );
+    }
     const isResumedSession = validatedResumeFrom != null || effectiveContinueFrom != null;
     let sandboxSession;
     let sessionWorkDir;
@@ -3930,6 +3967,7 @@ var HarnessAgent = class {
         pendingToolApprovals: effectiveContinueFrom == null ? void 0 : effectiveContinueFrom.pendingToolApprovals,
         pendingToolResults: effectiveContinueFrom == null ? void 0 : effectiveContinueFrom.pendingToolResults,
         turnSettings: effectiveContinueFrom == null ? void 0 : effectiveContinueFrom.turnSettings,
+        resumedToolsContext: options == null ? void 0 : options.toolsContext,
         turnState: effectiveContinueFrom == null ? "idle" : effectiveContinueFrom.pendingToolApprovals != null && effectiveContinueFrom.pendingToolApprovals.length > 0 ? "awaiting-approval" : effectiveContinueFrom.pendingToolResults != null && effectiveContinueFrom.pendingToolResults.length > 0 ? "awaiting-tool-result" : "suspended"
       });
     } catch (error) {
@@ -4053,6 +4091,7 @@ var HarnessAgent = class {
       skills: input.turnSettings.skills,
       instructions: input.turnSettings.instructions,
       tools: input.turnSettings.tools,
+      toolsContext: input.turnSettings.toolsContext,
       activeTools: input.turnSettings.activeTools,
       toolSpecs: input.turnSettings.toolSpecs,
       builtinToolFiltering: input.turnSettings.builtinToolFiltering,
@@ -4135,7 +4174,7 @@ var HarnessAgent = class {
     throw new Error("HarnessAgent: either `prompt` or `messages` is required.");
   }
   async _preparePromptTurnInput(options) {
-    var _a4, _b4, _c;
+    var _a4, _b4, _c, _d;
     let callOptions = options;
     if (this.settings.callOptionsSchema != null && options.options !== void 0) {
       const validatedOptions = await validateTypes({
@@ -4172,12 +4211,13 @@ var HarnessAgent = class {
       skills: this.settings.skills,
       instructions: this.settings.instructions,
       tools: this.settings.tools,
+      toolsContext: (_a4 = this.settings.toolsContext) != null ? _a4 : {},
       ...promptOptions
     };
-    const preparedCallArgs = (_c = await ((_b4 = (_a4 = this.settings).prepareCall) == null ? void 0 : _b4.call(
-      _a4,
+    const preparedCallArgs = (_d = await ((_c = (_b4 = this.settings).prepareCall) == null ? void 0 : _c.call(
+      _b4,
       baseCallArgs
-    ))) != null ? _c : baseCallArgs;
+    ))) != null ? _d : baseCallArgs;
     if (this._resolveContinueTurnInput(preparedCallArgs) != null) {
       throw new Error(
         "HarnessAgent.prepareCall must return a fresh user prompt, not a tool continuation."
@@ -4189,7 +4229,8 @@ var HarnessAgent = class {
         model: preparedCallArgs.model,
         skills: preparedCallArgs.skills,
         instructions: preparedCallArgs.instructions,
-        tools: preparedCallArgs.tools
+        tools: preparedCallArgs.tools,
+        toolsContext: preparedCallArgs.toolsContext
       })
     };
   }
@@ -4200,14 +4241,15 @@ var HarnessAgent = class {
         model: this.settings.model,
         skills: this.settings.skills,
         instructions: this.settings.instructions,
-        tools: this.settings.tools
+        tools: this.settings.tools,
+        toolsContext: this.settings.toolsContext
       }),
       toolApprovalContinuations: (_a4 = options.toolApprovalContinuations) != null ? _a4 : [],
       toolResultContinuations: (_b4 = options.toolResultContinuations) != null ? _b4 : []
     };
   }
   _prepareTurnSettings(options) {
-    var _a4, _b4, _c;
+    var _a4, _b4, _c, _d;
     const userTools = (_a4 = options.tools) != null ? _a4 : {};
     assertNoReservedQuestionTool({
       harness: this.settings.harness,
@@ -4229,6 +4271,7 @@ var HarnessAgent = class {
       skills: (_b4 = options.skills) != null ? _b4 : [],
       instructions: typeof options.instructions === "string" ? options.instructions : (_c = options.instructions) == null ? void 0 : _c.content,
       tools,
+      toolsContext: (_d = options.toolsContext) != null ? _d : {},
       activeTools: toolFiltering.activeUserTools,
       toolSpecs: this._toToolSpecs(toolFiltering.activeUserTools),
       builtinToolFiltering: toolFiltering.builtinToolFiltering