@ai-sdk/harness 1.0.117 → 1.0.119

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness",
-  "version": "1.0.117",
+  "version": "1.0.119",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -46,7 +46,7 @@
   "dependencies": {
     "@ai-sdk/provider": "4.0.17",
     "@ai-sdk/provider-utils": "5.0.45",
-    "ai": "7.0.107"
+    "ai": "7.0.109"
   },
   "peerDependencies": {
     "ws": "^8.21.0",
@@ -58,7 +58,7 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/otel": "1.0.107",
+    "@ai-sdk/otel": "1.0.109",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",
     "@types/ws": "^8.5.13",

package/src/agent/harness-agent-session.ts

@@ -1,6 +1,7 @@
 import type {
   Context,
   Experimental_SandboxSession as SandboxSession,
+  InferToolSetContext,
   ToolApprovalResponse,
   ToolResultPart,
   ToolSet,
@@ -65,6 +66,7 @@ type ActivePromptControl = {
 type ActiveTurnSettings = {
   readonly persisted: HarnessV1TurnSettings;
   readonly tools: ToolSet;
+  readonly toolsContext: Record<string, Context | undefined>;
   readonly activeTools: ToolSet;
   readonly builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
 };
@@ -119,6 +121,9 @@ export class HarnessAgentSession {
     | undefined;
   private activeTurnSettings: ActiveTurnSettings | undefined;
   private persistedTurnSettings: HarnessV1TurnSettings | undefined;
+  private readonly resumedToolsContext:
+    | Record<string, Context | undefined>
+    | undefined;
 
   /**
    * Whether this session was created from `resumeFrom` or `continueFrom`.
@@ -137,6 +142,7 @@ export class HarnessAgentSession {
     pendingToolApprovals?: readonly HarnessAgentPendingToolApproval[];
     pendingToolResults?: readonly HarnessAgentPendingToolResult[];
     turnSettings?: HarnessV1TurnSettings;
+    resumedToolsContext?: Record<string, Context | undefined>;
     turnState?: HarnessAgentTurnState;
   }) {
     this.sessionId = options.sessionId;
@@ -153,6 +159,7 @@ export class HarnessAgentSession {
       this.pendingToolResults.set(pendingResult.toolCallId, pendingResult);
     }
     this.persistedTurnSettings = options.turnSettings;
+    this.resumedToolsContext = options.resumedToolsContext;
     this.turnState =
       options.turnState ??
       (this.pendingToolApprovals.size > 0
@@ -201,6 +208,7 @@ export class HarnessAgentSession {
     skills: ReadonlyArray<HarnessV1Skill>;
     instructions: string | undefined;
     tools: TOOLS;
+    toolsContext: InferToolSetContext<TOOLS>;
     activeTools: ToolSet;
     toolSpecs: HarnessAgentToolSpec[];
     builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
@@ -225,6 +233,7 @@ export class HarnessAgentSession {
     this.activeTurnSettings = {
       persisted: this.persistedTurnSettings,
       tools: options.tools,
+      toolsContext: options.toolsContext,
       activeTools: options.activeTools,
       builtinToolFiltering: options.builtinToolFiltering,
     };
@@ -239,6 +248,7 @@ export class HarnessAgentSession {
         skills: options.skills,
         instructions: options.instructions,
         tools: options.tools,
+        toolsContext: options.toolsContext,
         activeTools: options.activeTools,
         toolSpecs: options.toolSpecs,
         builtinToolFiltering: options.builtinToolFiltering,
@@ -302,6 +312,7 @@ export class HarnessAgentSession {
     skills: ReadonlyArray<HarnessV1Skill>;
     instructions: string | undefined;
     tools: TOOLS;
+    toolsContext: InferToolSetContext<TOOLS>;
     activeTools: ToolSet;
     toolSpecs: HarnessAgentToolSpec[];
     builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
@@ -322,6 +333,7 @@ export class HarnessAgentSession {
       skills: options.skills,
       instructions: options.instructions,
       tools: options.tools,
+      toolsContext: options.toolsContext,
       activeTools: options.activeTools,
       toolSpecs: options.toolSpecs,
       builtinToolFiltering: options.builtinToolFiltering,
@@ -337,6 +349,7 @@ export class HarnessAgentSession {
         skills: turnSettings.persisted.skills,
         instructions: turnSettings.persisted.instructions,
         tools: turnSettings.tools as TOOLS,
+        toolsContext: turnSettings.toolsContext as InferToolSetContext<TOOLS>,
         activeTools: turnSettings.activeTools,
         toolSpecs: [...turnSettings.persisted.tools],
         builtinToolFiltering: turnSettings.builtinToolFiltering,
@@ -778,6 +791,7 @@ export class HarnessAgentSession {
     skills: ReadonlyArray<HarnessV1Skill>;
     instructions: string | undefined;
     tools: ToolSet;
+    toolsContext: Record<string, Context | undefined>;
     activeTools: ToolSet;
     toolSpecs: HarnessAgentToolSpec[];
     builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
@@ -811,6 +825,7 @@ export class HarnessAgentSession {
     this.activeTurnSettings = {
       persisted,
       tools: options.tools,
+      toolsContext: this.resumedToolsContext ?? options.toolsContext,
       activeTools,
       builtinToolFiltering: options.builtinToolFiltering,
     };

package/src/agent/harness-agent-settings.ts

@@ -13,6 +13,7 @@ import type {
   Context,
   Experimental_SandboxSession as SandboxSession,
   FlexibleSchema,
+  InferToolSetContext,
   MaybePromiseLike,
   SystemModelMessage,
   ToolSet,
@@ -34,6 +35,7 @@ import type {
   TelemetryOptions,
   ToolApprovalStatus,
 } from 'ai';
+import type { ToolsContextSettings } from 'ai/internal';
 import type { HarnessAllTools } from './harness-agent-tool-types';
 
 export type HarnessAgentToolApprovalConfiguration = Readonly<
@@ -150,6 +152,13 @@ export type HarnessAgentSettings<
    */
   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.
@@ -225,7 +234,9 @@ export type HarnessAgentSettings<
           CALL_OPTIONS
         >,
         'model' | 'skills' | 'instructions' | 'tools'
-      >,
+      > & {
+        toolsContext: InferToolSetContext<TUserTools>;
+      },
   ) => MaybePromiseLike<
     Pick<
       HarnessAgentSettings<
@@ -236,8 +247,9 @@ export type HarnessAgentSettings<
         CALL_OPTIONS
       >,
       'model' | 'skills' | 'instructions' | 'tools'
-    > &
-      Omit<Prompt, 'system' | 'instructions' | 'allowSystemInMessages'>
+    > & {
+      toolsContext: InferToolSetContext<TUserTools>;
+    } & Omit<Prompt, 'system' | 'instructions' | 'allowSystemInMessages'>
   >;
 
   /**
@@ -376,4 +388,5 @@ export type HarnessAgentSettings<
    * stderr default — wire this to capture diagnostics in code.
    */
   readonly onLog?: (event: HarnessDiagnostic) => void;
-} & HarnessAgentToolFilteringSettings<HarnessAllTools<THarness, TUserTools>>;
+} & ToolsContextSettings<TUserTools> &
+  HarnessAgentToolFilteringSettings<HarnessAllTools<THarness, TUserTools>>;

package/src/agent/harness-agent.ts

@@ -10,6 +10,7 @@ import {
   asArray,
   asSchema,
   generateId,
+  type InferToolSetContext,
   normalizeHeaders,
   validateTypes,
   type Context,
@@ -20,7 +21,7 @@ import {
   type ToolResultPart,
   type ToolSet,
 } from '@ai-sdk/provider-utils';
-import { mergeCallbacks } from 'ai/internal';
+import { mergeCallbacks, type ToolsContextSettings } from 'ai/internal';
 import type {
   Agent,
   AgentCallParameters,
@@ -99,6 +100,7 @@ type PreparedHarnessAgentTurnSettings<
   skills: ReadonlyArray<HarnessAgentSkill>;
   instructions: string | undefined;
   tools: HarnessAllTools<THarness, TUserTools>;
+  toolsContext: InferToolSetContext<HarnessAllTools<THarness, TUserTools>>;
   activeTools: TUserTools;
   toolSpecs: HarnessAgentToolSpec[];
   builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
@@ -314,6 +316,13 @@ export class HarnessAgent<
      * 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.
@@ -356,6 +365,11 @@ export class HarnessAgent<
 
     const effectiveContinueFrom =
       validatedContinueFrom ?? validatedResumeFrom?.continueFrom;
+    if (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;
 
@@ -552,6 +566,7 @@ export class HarnessAgent<
         pendingToolApprovals: effectiveContinueFrom?.pendingToolApprovals,
         pendingToolResults: effectiveContinueFrom?.pendingToolResults,
         turnSettings: effectiveContinueFrom?.turnSettings,
+        resumedToolsContext: options?.toolsContext,
         turnState:
           effectiveContinueFrom == null
             ? 'idle'
@@ -785,6 +800,7 @@ export class HarnessAgent<
       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,
@@ -943,6 +959,8 @@ export class HarnessAgent<
       skills: this.settings.skills,
       instructions: this.settings.instructions,
       tools: this.settings.tools,
+      toolsContext:
+        this.settings.toolsContext ?? ({} as InferToolSetContext<TUserTools>),
       ...promptOptions,
     };
     const preparedCallArgs =
@@ -972,6 +990,7 @@ export class HarnessAgent<
         skills: preparedCallArgs.skills,
         instructions: preparedCallArgs.instructions,
         tools: preparedCallArgs.tools,
+        toolsContext: preparedCallArgs.toolsContext,
       }),
     };
   }
@@ -986,6 +1005,7 @@ export class HarnessAgent<
         skills: this.settings.skills,
         instructions: this.settings.instructions,
         tools: this.settings.tools,
+        toolsContext: this.settings.toolsContext,
       }),
       toolApprovalContinuations: options.toolApprovalContinuations ?? [],
       toolResultContinuations: options.toolResultContinuations ?? [],
@@ -997,6 +1017,7 @@ export class HarnessAgent<
     skills?: ReadonlyArray<HarnessAgentSkill>;
     instructions?: string | SystemModelMessage;
     tools?: TUserTools;
+    toolsContext?: InferToolSetContext<TUserTools>;
   }): PreparedHarnessAgentTurnSettings<THarness, TUserTools> {
     const userTools = options.tools ?? ({} as TUserTools);
     assertNoReservedQuestionTool({
@@ -1022,6 +1043,9 @@ export class HarnessAgent<
           ? options.instructions
           : options.instructions?.content,
       tools,
+      toolsContext: (options.toolsContext ?? {}) as InferToolSetContext<
+        HarnessAllTools<THarness, TUserTools>
+      >,
       activeTools: toolFiltering.activeUserTools,
       toolSpecs: this._toToolSpecs(toolFiltering.activeUserTools),
       builtinToolFiltering: toolFiltering.builtinToolFiltering,

package/src/agent/internal/get-own.ts

@@ -0,0 +1,8 @@
+export function getOwn<T extends object>(
+  obj: T | undefined | null,
+  key: string,
+): T[keyof T] | undefined {
+  return obj != null && Object.prototype.hasOwnProperty.call(obj, key)
+    ? obj[key as keyof T]
+    : undefined;
+}

package/src/agent/internal/run-prompt.ts

@@ -32,7 +32,11 @@ import {
   type LanguageModelV4ToolCall,
   type LanguageModelV4Usage,
 } from '@ai-sdk/provider';
-import { asLanguageModelUsage, parseToolCall } from 'ai/internal';
+import {
+  asLanguageModelUsage,
+  parseToolCall,
+  validateToolContext,
+} from 'ai/internal';
 import type {
   ContentPart,
   OutputInterface as Output,
@@ -47,6 +51,7 @@ import type {
 } from 'ai';
 import type { HarnessAgentToolApprovalConfiguration } from '../harness-agent-settings';
 import { HarnessStreamTextResult } from './harness-stream-text-result';
+import { getOwn } from './get-own';
 import { translateStreamPart } from './translate-stream-part';
 import { createToolInputWorkDirStripper, stripWorkDir } from './strip-work-dir';
 import {
@@ -112,6 +117,7 @@ export function runPrompt<
   skills?: ReadonlyArray<HarnessV1Skill>;
   instructions: string | undefined;
   tools: TOOLS;
+  toolsContext?: InferToolSetContext<TOOLS>;
   activeTools?: ToolSet;
   toolSpecs: HarnessV1ToolSpec[];
   builtinToolFiltering?: HarnessV1BuiltinToolFiltering | undefined;
@@ -147,7 +153,7 @@ export function runPrompt<
   done: Promise<void>;
 } {
   const callId = generateId();
-  const toolsContext = {} as InferToolSetContext<TOOLS>;
+  const toolsContext = input.toolsContext ?? ({} as InferToolSetContext<TOOLS>);
   const result = new HarnessStreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>({
     tools: input.tools,
     runtimeContext: input.runtimeContext,
@@ -701,6 +707,7 @@ export function runPrompt<
       const execution = await maybeExecuteHostTool({
         event: rawToolCall,
         tools: activeTools,
+        toolsContext,
         wrappedExecuteTool: lifecycle.executeTool,
         sandboxSession: input.sandboxSession,
         abortSignal: input.abortSignal,
@@ -1260,6 +1267,7 @@ export function runPrompt<
               const execution = await maybeExecuteHostTool({
                 event: toolCall,
                 tools: activeTools,
+                toolsContext,
                 wrappedExecuteTool: lifecycle.executeTool,
                 sandboxSession: input.sandboxSession,
                 abortSignal: input.abortSignal,
@@ -1426,6 +1434,7 @@ function hasTool(input: { tools: ToolSet; toolName: string }): boolean {
 async function maybeExecuteHostTool<TOOLS extends ToolSet>(input: {
   event: { toolCallId: string; toolName: string; input: string };
   tools: TOOLS;
+  toolsContext: InferToolSetContext<TOOLS>;
   wrappedExecuteTool: TurnLifecycle<ToolSet, Context>['executeTool'];
   sandboxSession: SandboxSession;
   abortSignal: AbortSignal | undefined;
@@ -1444,6 +1453,25 @@ async function maybeExecuteHostTool<TOOLS extends ToolSet>(input: {
   const parsed = await safeParseJSON({ text: input.event.input });
   const args = parsed.success ? parsed.value : input.event.input;
 
+  let context: unknown;
+  try {
+    context = await validateToolContext({
+      toolName: input.event.toolName,
+      context: getOwn(input.toolsContext, input.event.toolName),
+      contextSchema: tool.contextSchema,
+    });
+  } catch (err) {
+    // Context is host-only and can contain credentials. Keep the detailed
+    // validation error in the host-facing outcome, but never send its value or
+    // schema diagnostics back to the runtime/model.
+    await input.submitToolResult({
+      toolCallId: input.event.toolCallId,
+      output: { error: 'Tool context validation failed.' },
+      isError: true,
+    });
+    return { executed: true, outcome: { ok: false, error: err } };
+  }
+
   try {
     /*
      * Normalize the tool's return value through `executeTool`, the same helper
@@ -1466,7 +1494,7 @@ async function maybeExecuteHostTool<TOOLS extends ToolSet>(input: {
             toolCallId: input.event.toolCallId,
             messages: [],
             abortSignal: input.abortSignal,
-            context: undefined as never,
+            context: context as never,
             experimental_sandbox: input.sandboxSession,
           },
         });

package/src/agent/internal/strip-work-dir.ts

@@ -12,36 +12,63 @@ export function createToolInputWorkDirStripper({
 }: {
   sessionWorkDir: string;
 }): (part: ToolInputStreamPart) => ToolInputStreamPart[] {
-  const pendingByToolCallId = new Map<string, string>();
+  const stateByToolCallId = new Map<
+    string,
+    {
+      pending: string;
+      precedingCharacter: string | undefined;
+    }
+  >();
 
   return part => {
     if (sessionWorkDir.length === 0) return [part];
 
     if (part.type === 'tool-input-start') {
-      pendingByToolCallId.set(part.id, '');
+      stateByToolCallId.set(part.id, {
+        pending: '',
+        precedingCharacter: undefined,
+      });
       return [part];
     }
 
     if (part.type === 'tool-input-delta') {
+      const state = stateByToolCallId.get(part.id) ?? {
+        pending: '',
+        precedingCharacter: undefined,
+      };
+      const value = state.pending + part.delta;
       const stripped = stripStreamingString({
-        value: (pendingByToolCallId.get(part.id) ?? '') + part.delta,
+        value,
         workDir: sessionWorkDir,
         final: false,
+        precedingCharacter: state.precedingCharacter,
+      });
+      const pendingStart = value.length - stripped.pending.length;
+      stateByToolCallId.set(part.id, {
+        pending: stripped.pending,
+        precedingCharacter:
+          stripped.pending.length > 0
+            ? pendingStart > 0
+              ? value[pendingStart - 1]
+              : state.precedingCharacter
+            : value.length > 0
+              ? value[value.length - 1]
+              : state.precedingCharacter,
       });
-      pendingByToolCallId.set(part.id, stripped.pending);
       return stripped.output.length === 0
         ? []
         : [{ ...part, delta: stripped.output }];
     }
 
-    const pending = pendingByToolCallId.get(part.id);
-    pendingByToolCallId.delete(part.id);
-    if (pending == null || pending.length === 0) return [part];
+    const state = stateByToolCallId.get(part.id);
+    stateByToolCallId.delete(part.id);
+    if (state == null || state.pending.length === 0) return [part];
 
     const stripped = stripStreamingString({
-      value: pending,
+      value: state.pending,
       workDir: sessionWorkDir,
       final: true,
+      precedingCharacter: state.precedingCharacter,
     });
     return stripped.output.length === 0
       ? [part]
@@ -62,11 +89,10 @@ export function createToolInputWorkDirStripper({
  * operates. The absolute paths are correct but noisy in a UI, so this strips
  * the prefix for the consumer-facing projection only.
  *
- * Blanket prefix replacement (rather than rewriting known path fields) is used
- * deliberately: `tool-result` results are free-form text — command stdout, grep
- * output — where paths can appear anywhere and field-aware rewriting is
- * impossible. The prefix is long and contains the session id, so it is unique
- * enough that replacing every occurrence is safe.
+ * Boundary-aware prefix replacement (rather than rewriting known path fields)
+ * is used deliberately: `tool-result` results are free-form text — command
+ * stdout, grep output — where paths can appear anywhere and field-aware
+ * rewriting is impossible.
  */
 export function stripWorkDir(
   part: HarnessV1StreamPart,
@@ -101,33 +127,60 @@ export function stripWorkDir(
  * becomes `.`.
  */
 function stripString(value: string, workDir: string): string {
-  return value.split(`${workDir}/`).join('').split(workDir).join('.');
+  return stripStreamingString({
+    value,
+    workDir,
+    final: true,
+    precedingCharacter: undefined,
+  }).output;
 }
 
 function stripStreamingString({
   value,
   workDir,
   final,
+  precedingCharacter,
 }: {
   value: string;
   workDir: string;
   final: boolean;
+  precedingCharacter: string | undefined;
 }): { output: string; pending: string } {
   let remaining = value;
   let output = '';
+  let characterBeforeRemaining = precedingCharacter;
 
   while (remaining.length > 0) {
     const matchIndex = remaining.indexOf(workDir);
     if (matchIndex >= 0) {
-      output += remaining.slice(0, matchIndex);
       const followingIndex = matchIndex + workDir.length;
-      if (followingIndex === remaining.length && !final) {
-        return { output, pending: remaining.slice(matchIndex) };
+      const hasPathBoundary = isPathBoundary(
+        remaining,
+        matchIndex,
+        characterBeforeRemaining,
+      );
+      if (hasPathBoundary && followingIndex === remaining.length && !final) {
+        return {
+          output: output + remaining.slice(0, matchIndex),
+          pending: remaining.slice(matchIndex),
+        };
       }
-      if (remaining[followingIndex] === '/') {
+
+      const isPath =
+        hasPathBoundary &&
+        (followingIndex === remaining.length ||
+          remaining[followingIndex] === '/' ||
+          isPathTerminator(remaining[followingIndex]));
+      if (!isPath) {
+        output += remaining.slice(0, followingIndex);
+        characterBeforeRemaining = remaining[followingIndex - 1];
+        remaining = remaining.slice(followingIndex);
+      } else if (remaining[followingIndex] === '/') {
+        output += remaining.slice(0, matchIndex);
+        characterBeforeRemaining = remaining[followingIndex];
         remaining = remaining.slice(followingIndex + 1);
       } else {
-        output += '.';
+        output += remaining.slice(0, matchIndex) + '.';
         remaining = remaining.slice(followingIndex);
       }
       continue;
@@ -138,7 +191,12 @@ function stripStreamingString({
     let pendingLength = Math.min(remaining.length, workDir.length - 1);
     while (
       pendingLength > 0 &&
-      !workDir.startsWith(remaining.slice(-pendingLength))
+      (!workDir.startsWith(remaining.slice(-pendingLength)) ||
+        !isPathBoundary(
+          remaining,
+          remaining.length - pendingLength,
+          characterBeforeRemaining,
+        ))
     ) {
       pendingLength -= 1;
     }
@@ -152,6 +210,19 @@ function stripStreamingString({
   return { output, pending: '' };
 }
 
+function isPathBoundary(
+  value: string,
+  index: number,
+  precedingCharacter?: string,
+): boolean {
+  const character = index === 0 ? precedingCharacter : value[index - 1]!;
+  return character === undefined || /[\s"'`=]/.test(character);
+}
+
+function isPathTerminator(character: string | undefined): boolean {
+  return character === undefined || /[\s"'`;|&<>()]/.test(character);
+}
+
 /**
  * Recursively strip the working directory from every string nested in an
  * arbitrary JSON-like value. Non-string leaves are returned unchanged.

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 export {
   SandboxChannel,
+  type SandboxChannelConnectOptions,
   type SandboxChannelDebugEvent,
   type SandboxChannelOptions,
   type SandboxChannelReconnectOptions,
@@ -69,3 +70,4 @@ export {
 } from './bridge-diagnostics';
 export { resolveSandboxDefaultWorkingDirectory } from './resolve-sandbox-default-working-directory';
 export { getRestrictedSandboxSession } from './get-restricted-sandbox-session';
+export { sleep } from './sleep';