@ai-sdk/harness 1.0.92 → 1.0.94

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

@@ -9,6 +9,7 @@ import {
   type HarnessV1PromptControl,
   type HarnessV1ResponseFormat,
   type HarnessV1Session,
+  type HarnessV1Skill,
   type HarnessV1StreamPart,
   type HarnessV1ToolSpec,
 } from '../../v1';
@@ -43,7 +44,7 @@ import type { HarnessAgentToolResultContinuation } from '../harness-agent-tool-r
 import type { HarnessAgentToolApprovalConfiguration } from '../harness-agent-settings';
 import { HarnessStreamTextResult } from './harness-stream-text-result';
 import { translateStreamPart } from './translate-stream-part';
-import { stripWorkDir } from './strip-work-dir';
+import { createToolInputWorkDirStripper, stripWorkDir } from './strip-work-dir';
 import {
   createTurnTelemetry,
   type TurnContentPart,
@@ -80,6 +81,8 @@ export function runPrompt<
   mode?: 'prompt' | 'continue';
   /** Required for `mode: 'prompt'`; absent for `mode: 'continue'`. */
   prompt?: HarnessV1Prompt;
+  model?: string;
+  skills?: ReadonlyArray<HarnessV1Skill>;
   instructions: string | undefined;
   tools: TOOLS;
   activeTools?: ToolSet;
@@ -139,7 +142,7 @@ export function runPrompt<
   const telemetry = createTurnTelemetry({
     telemetry: input.telemetry,
     harnessId: input.harness.harnessId,
-    modelId: input.session.modelId,
+    modelId: input.model,
     instructions: input.instructions,
     promptText: input.prompt != null ? promptToText(input.prompt) : '',
     runtimeContext: input.runtimeContext,
@@ -179,6 +182,8 @@ export function runPrompt<
           input.mode === 'continue'
             ? emit =>
                 input.session.doContinueTurn({
+                  model: input.model,
+                  skills: input.skills ?? [],
                   responseFormat: input.responseFormat,
                   tools: input.toolSpecs,
                   instructions: input.instructions,
@@ -193,6 +198,8 @@ export function runPrompt<
                 }
                 return input.session.doPromptTurn({
                   prompt: input.prompt,
+                  model: input.model,
+                  skills: input.skills ?? [],
                   responseFormat: input.responseFormat,
                   tools: input.toolSpecs,
                   instructions: input.instructions,
@@ -216,6 +223,9 @@ export function runPrompt<
     const { stream, control } = bridge;
     input.onPromptControlAvailable?.(control);
     const reader = stream.getReader();
+    const stripToolInputWorkDir = createToolInputWorkDirStripper({
+      sessionWorkDir: input.sessionWorkDir,
+    });
     const toolCallsByToolCallId = new Map<string, ToolCallTextStreamPart>();
     const rawToolCallsByToolCallId = new Map<
       string,
@@ -530,7 +540,7 @@ export function runPrompt<
           input: approval.input,
         } satisfies Extract<HarnessV1StreamPart, { type: 'tool-call' }>);
 
-      await telemetry.start(input.session.modelId);
+      await telemetry.start(input.model);
       await telemetry.toolStart({
         toolCallId: rawToolCall.toolCallId,
         toolName: rawToolCall.toolName,
@@ -645,9 +655,9 @@ export function runPrompt<
         }
 
         // Begin the operation span on stream-start, using the runtime-resolved
-        // model the adapter reports (falling back to the session's model).
+        // model the adapter reports (falling back to the requested turn model).
         if (value.type === 'stream-start') {
-          await telemetry.start(value.modelId ?? input.session.modelId);
+          await telemetry.start(value.modelId ?? input.model);
         }
 
         // Open a step span lazily before the first content of each step.
@@ -660,6 +670,28 @@ export function runPrompt<
           await telemetry.ensureStepOpen();
         }
 
+        if (
+          value.type === 'tool-input-start' ||
+          value.type === 'tool-input-delta' ||
+          value.type === 'tool-input-end'
+        ) {
+          if (
+            settledHostToolCallIds.has(value.id) ||
+            settledBuiltinApprovalToolCallIds.has(value.id)
+          ) {
+            continue;
+          }
+          for (const displayValue of stripToolInputWorkDir(value)) {
+            for (const part of translateStreamPart<TOOLS>(
+              displayValue,
+              translateOptions,
+            )) {
+              result.enqueue(part);
+            }
+          }
+          continue;
+        }
+
         /*
          * Strip the session working-directory prefix for everything the
          * consumer sees. The original `value` is kept intact for host tool
@@ -734,12 +766,18 @@ export function runPrompt<
           // paths help debugging); the consumer-facing settle uses the
           // workDir-stripped one, like every other forwarded part.
           await telemetry.error(value.error);
-          logBridgeError({
-            harnessId: input.harness.harnessId,
-            sessionId: input.session.sessionId,
-            context: 'harness stream error',
-            error: value.error,
-          });
+          // A turn the caller itself aborted ends with an error-shaped part by
+          // construction; diagnosing the caller's own signal to stderr reads
+          // as a malfunction. `settleFailure` below still reports it as an
+          // abort to the consumer.
+          if (!input.abortSignal?.aborted) {
+            logBridgeError({
+              harnessId: input.harness.harnessId,
+              sessionId: input.session.sessionId,
+              context: 'harness stream error',
+              error: value.error,
+            });
+          }
           settleFailure(displayValue.error);
           return;
         }

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

@@ -1,5 +1,57 @@
 import type { HarnessV1StreamPart } from '../../v1';
 
+type ToolInputStreamPart = Extract<
+  HarnessV1StreamPart,
+  {
+    type: 'tool-input-start' | 'tool-input-delta' | 'tool-input-end';
+  }
+>;
+
+export function createToolInputWorkDirStripper({
+  sessionWorkDir,
+}: {
+  sessionWorkDir: string;
+}): (part: ToolInputStreamPart) => ToolInputStreamPart[] {
+  const pendingByToolCallId = new Map<string, string>();
+
+  return part => {
+    if (sessionWorkDir.length === 0) return [part];
+
+    if (part.type === 'tool-input-start') {
+      pendingByToolCallId.set(part.id, '');
+      return [part];
+    }
+
+    if (part.type === 'tool-input-delta') {
+      const stripped = stripStreamingString({
+        value: (pendingByToolCallId.get(part.id) ?? '') + part.delta,
+        workDir: sessionWorkDir,
+        final: false,
+      });
+      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 stripped = stripStreamingString({
+      value: pending,
+      workDir: sessionWorkDir,
+      final: true,
+    });
+    return stripped.output.length === 0
+      ? [part]
+      : [
+          { type: 'tool-input-delta', id: part.id, delta: stripped.output },
+          part,
+        ];
+  };
+}
+
 /**
  * Remove the session working-directory prefix from path-bearing fields of a
  * stream event, returning a new event for display to consumers.
@@ -23,6 +75,8 @@ export function stripWorkDir(
   if (sessionWorkDir.length === 0) return part;
 
   switch (part.type) {
+    case 'tool-input-delta':
+      return { ...part, delta: stripString(part.delta, sessionWorkDir) };
     case 'tool-call':
       return { ...part, input: stripString(part.input, sessionWorkDir) };
     case 'tool-result':
@@ -50,6 +104,54 @@ function stripString(value: string, workDir: string): string {
   return value.split(`${workDir}/`).join('').split(workDir).join('.');
 }
 
+function stripStreamingString({
+  value,
+  workDir,
+  final,
+}: {
+  value: string;
+  workDir: string;
+  final: boolean;
+}): { output: string; pending: string } {
+  let remaining = value;
+  let output = '';
+
+  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) };
+      }
+      if (remaining[followingIndex] === '/') {
+        remaining = remaining.slice(followingIndex + 1);
+      } else {
+        output += '.';
+        remaining = remaining.slice(followingIndex);
+      }
+      continue;
+    }
+
+    if (final) return { output: output + remaining, pending: '' };
+
+    let pendingLength = Math.min(remaining.length, workDir.length - 1);
+    while (
+      pendingLength > 0 &&
+      !workDir.startsWith(remaining.slice(-pendingLength))
+    ) {
+      pendingLength -= 1;
+    }
+    const outputLength = remaining.length - pendingLength;
+    return {
+      output: output + remaining.slice(0, outputLength),
+      pending: remaining.slice(outputLength),
+    };
+  }
+
+  return { output, pending: '' };
+}
+
 /**
  * Recursively strip the working directory from every string nested in an
  * arbitrary JSON-like value. Non-string leaves are returned unchanged.

package/src/agent/internal/translate-stream-part.ts

@@ -103,6 +103,11 @@ export function translateStreamPart<TOOLS extends ToolSet>(
         } as TextStreamPart<TOOLS>,
       ];
 
+    case 'tool-input-start':
+    case 'tool-input-delta':
+    case 'tool-input-end':
+      return [event as TextStreamPart<TOOLS>];
+
     case 'tool-call':
       // Tool-call validation is async (it parses input against the tool's
       // schema) and lives in `run-prompt.ts` where the merged tool set is in

package/src/bridge/index.ts

@@ -293,8 +293,27 @@ export interface RunBridgeOptions<TStart extends { type: 'start' }> {
   bridgeType: string;
   /** Directory for `bridge-meta.json` / `start-config.json`. Created if absent. */
   bridgeStateDir: string;
-  /** Drive one prompt turn. Rejections surface to the host as an `error` event. */
+  /**
+   * Drive one prompt turn. Rejections surface to the host as an `error`
+   * event.
+   *
+   * Contract: once `turn.abortSignal` fires, wind down promptly — turns are
+   * serialized, and a replacement `start` waits up to
+   * {@link turnTeardownGraceMs} for this promise to settle before it
+   * proceeds anyway.
+   */
   onStart(start: TStart, turn: BridgeTurn): Promise<void>;
+  /**
+   * How long a replacement `start` waits for the previous turn's teardown
+   * after aborting it, in milliseconds. Turns are serialized so an aborted
+   * turn cannot emit into its replacement's event log or overlap its runtime
+   * process — but only within this bound: an adapter that does not settle
+   * `onStart` after its abort signal fires forfeits the protection for that
+   * boundary, and the new turn proceeds anyway rather than blocking forever.
+   * The default of ten seconds exceeds the Claude bridge's five-second
+   * hard-abort fallback.
+   */
+  turnTeardownGraceMs?: number;
   /**
    * Produce the adapter-defined runtime resume data for `stop`. Defaults to
    * `{}`.
@@ -355,6 +374,7 @@ export async function runBridge<TStart extends { type: 'start' }>(
   options: RunBridgeOptions<TStart>,
 ): Promise<BridgeHandle> {
   const { bridgeType, bridgeStateDir, onStart, onStop, onDestroy } = options;
+  const teardownGraceMs = options.turnTeardownGraceMs ?? 10_000;
   const expectedToken = options.token ?? procEnv.BRIDGE_CHANNEL_TOKEN ?? '';
   const bridgeWsPort =
     options.port ?? parseInt(procEnv.BRIDGE_WS_PORT ?? '0', 10);
@@ -384,6 +404,12 @@ export async function runBridge<TStart extends { type: 'start' }>(
   let isFirstTurn = true;
   let turnAbort: AbortController | undefined;
   let currentUserMessages: InternalBridgeUserMessageQueue | undefined;
+  /**
+   * Settles when the in-flight turn has fully wound down — `onStart`
+   * returned or threw AND its completion state was recorded. `undefined`
+   * between turns. A new `start` fences on this so turns never overlap.
+   */
+  let activeTurn: Promise<void> | undefined;
 
   // Diagnostics. Resolved per turn from `start.debug` with a sandbox-side
   // env fallback; gates console capture + structured `debug-event`s.
@@ -658,10 +684,44 @@ export async function runBridge<TStart extends { type: 'start' }>(
   ): Promise<void> => {
     switch (msg.type) {
       case 'start': {
+        /*
+         * A new turn replaces the active one — but only after the active one
+         * has fully wound down. Inbound frames are dispatched concurrently,
+         * and the host settles a caller abort immediately, so a retry's
+         * `start` can arrive while the aborted turn is still tearing down
+         * (e.g. a graceful interrupt). Without this fence the old turn would
+         * keep emitting into the new turn's cleared event log, two runtime
+         * processes would run side by side, and the old turn's completion
+         * would mark the bridge `waiting` underneath the new turn. Abort the
+         * old turn to hasten its teardown; adapters are expected to bound
+         * that teardown themselves (e.g. a hard-abort fallback), but the
+         * runtime does not rely on it: the wait is capped by the teardown
+         * grace period, after which the new turn proceeds anyway — the
+         * pre-fence overlapping behavior — rather than hanging behind a
+         * teardown that never settles.
+         */
+        for (;;) {
+          const pendingTurn = activeTurn;
+          if (pendingTurn == null) break;
+          turnAbort?.abort();
+          currentUserMessages?.close(
+            new Error('A new bridge turn replaced the active turn.'),
+          );
+          let graceTimer: ReturnType<typeof setTimeout> | undefined;
+          const settled = await Promise.race([
+            pendingTurn.then(() => true as const),
+            new Promise<false>(resolve => {
+              graceTimer = setTimeout(() => resolve(false), teardownGraceMs);
+              graceTimer.unref?.();
+            }),
+          ]);
+          clearTimeout(graceTimer);
+          if (!settled) break;
+        }
+        let turnFinished!: () => void;
+        const thisTurn = new Promise<void>(resolve => (turnFinished = resolve));
+        activeTurn = thisTurn;
         activeSocket = ws; // asking for a turn claims the event stream
-        currentUserMessages?.close(
-          new Error('A new bridge turn replaced the active turn.'),
-        );
         const firstTurn = isFirstTurn;
         isFirstTurn = false;
         eventLog = []; // clear previous turn; keep seqCounter monotonic
@@ -727,8 +787,15 @@ export async function runBridge<TStart extends { type: 'start' }>(
           if (currentUserMessages === userMessages) {
             currentUserMessages = undefined;
           }
-          currentTurnState = 'waiting';
-          void writeBridgeMeta('waiting');
+          // Only the still-active turn records completion: after a fence
+          // timeout a replacement turn is already running, and this stale
+          // completion must not mark the bridge waiting underneath it.
+          if (activeTurn === thisTurn) {
+            activeTurn = undefined;
+            currentTurnState = 'waiting';
+            void writeBridgeMeta('waiting');
+          }
+          turnFinished();
         }
         return;
       }

package/src/utils/index.ts

@@ -30,6 +30,7 @@ export {
   writeSkills,
   type SkillFilePathMode,
   type WriteSkillsOptions,
+  type WriteSkillsResult,
 } from './write-skills';
 export {
   markBridgeStarting,