@ai-sdk/harness 1.0.107 → 1.0.109

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness",
-  "version": "1.0.107",
+  "version": "1.0.109",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -44,9 +44,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.13",
-    "@ai-sdk/provider-utils": "5.0.39",
-    "ai": "7.0.97"
+    "@ai-sdk/provider": "4.0.14",
+    "@ai-sdk/provider-utils": "5.0.40",
+    "ai": "7.0.99"
   },
   "peerDependencies": {
     "ws": "^8.21.0",
@@ -58,7 +58,7 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/otel": "1.0.97",
+    "@ai-sdk/otel": "1.0.99",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",
     "@types/ws": "^8.5.13",

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

@@ -112,6 +112,7 @@ export class HarnessAgentSession {
   private turnState: HarnessAgentTurnState;
   private turnSequence = 0;
   private activeTurnSequence = 0;
+  private activePromptDone: Promise<void> | undefined;
   private activePromptControl: ActivePromptControl | undefined;
   private suspendedTurnState:
     | Promise<HarnessAgentContinueTurnState>
@@ -281,6 +282,7 @@ export class HarnessAgentSession {
         onStopConditionMet: () =>
           this.captureStopConditionBoundary({ session, turnId }),
       });
+      this.activePromptDone = turn.done;
       return {
         ...turn,
         ready: this.waitForPromptControl({ turnId }),
@@ -380,6 +382,7 @@ export class HarnessAgentSession {
         onStopConditionMet: () =>
           this.captureStopConditionBoundary({ session, turnId }),
       });
+      this.activePromptDone = turn.done;
       return {
         ...turn,
         ready: this.waitForPromptControl({ turnId }),
@@ -463,7 +466,7 @@ export class HarnessAgentSession {
     try {
       if (this.turnState !== 'idle') {
         return this.toResumeStateWithContinuation({
-          continueFrom: await this.suspendCurrentTurn({ session }),
+          continueFrom: await this.finalizeCurrentTurnSuspension({ session }),
         });
       }
       const raw = await session.doDetach();
@@ -495,7 +498,7 @@ export class HarnessAgentSession {
     try {
       if (this.turnState !== 'idle') {
         return this.toResumeStateWithContinuation({
-          continueFrom: await this.suspendCurrentTurn({ session }),
+          continueFrom: await this.finalizeCurrentTurnSuspension({ session }),
         });
       }
       const raw = await session.doStop();
@@ -556,7 +559,7 @@ export class HarnessAgentSession {
     }
     const session = this.underlyingSession;
     try {
-      return await this.suspendCurrentTurn({ session });
+      return await this.finalizeCurrentTurnSuspension({ session });
     } finally {
       this.endLocalHandle({ sessionState: 'detached' });
     }
@@ -611,6 +614,17 @@ export class HarnessAgentSession {
     return state;
   }
 
+  private async finalizeCurrentTurnSuspension(options: {
+    session: HarnessAgentAdapterSession;
+  }): Promise<HarnessAgentContinueTurnState> {
+    const state = await this.suspendCurrentTurn(options);
+    // Freeze ingress first, then include all dispatched host work in the cursor.
+    // Keep this wait outside suspendCurrentTurn because stop-condition handling
+    // invokes that helper from inside the active prompt.
+    await this.activePromptDone;
+    return this.addPendingToolState(state);
+  }
+
   private async captureStopConditionBoundary(options: {
     session: HarnessAgentAdapterSession;
     turnId: number;

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

@@ -14,6 +14,7 @@ import type {
   Experimental_SandboxSession as SandboxSession,
   FlexibleSchema,
   MaybePromiseLike,
+  SystemModelMessage,
   ToolSet,
 } from '@ai-sdk/provider-utils';
 import type {
@@ -159,9 +160,10 @@ export type HarnessAgentSettings<
    * Instructions for the underlying agent runtime. Adapters append these to a
    * native system or developer prompt when supported. Otherwise, they prepend
    * them to the user message. `prepareCall` can replace them between completed
-   * turns.
+   * turns. When a `SystemModelMessage` is provided, only its `content` is
+   * forwarded to the harness adapter.
    */
-  readonly instructions?: string;
+  readonly instructions?: string | SystemModelMessage;
 
   /**
    * Additional HTTP headers to be sent with every model request.

package/src/agent/harness-agent.ts

@@ -15,6 +15,7 @@ import {
   type Context,
   type Experimental_SandboxSession as SandboxSession,
   type ModelMessage,
+  type SystemModelMessage,
   type ToolApprovalResponse,
   type ToolResultPart,
   type ToolSet,
@@ -280,6 +281,11 @@ export class HarnessAgent<
     return this.settings.harness.harnessId;
   }
 
+  /** Whether this agent parses completed turns with its configured output. */
+  get hasOutput(): boolean {
+    return this.settings.output != null;
+  }
+
   /**
    * Start a fresh session, or resume from state previously returned by
    * `session.detach()` or `session.stop()`. The returned
@@ -989,7 +995,7 @@ export class HarnessAgent<
   private _prepareTurnSettings(options: {
     model?: string;
     skills?: ReadonlyArray<HarnessAgentSkill>;
-    instructions?: string;
+    instructions?: string | SystemModelMessage;
     tools?: TUserTools;
   }): PreparedHarnessAgentTurnSettings<THarness, TUserTools> {
     const userTools = options.tools ?? ({} as TUserTools);
@@ -1011,7 +1017,10 @@ export class HarnessAgent<
     return {
       model: options.model,
       skills: options.skills ?? [],
-      instructions: options.instructions,
+      instructions:
+        typeof options.instructions === 'string'
+          ? options.instructions
+          : options.instructions?.content,
       tools,
       activeTools: toolFiltering.activeUserTools,
       toolSpecs: this._toToolSpecs(toolFiltering.activeUserTools),

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

@@ -539,28 +539,6 @@ export function runPrompt<
       onPendingToolResult(pendingResult);
       return pendingResult;
     };
-    const processPendingToolResultContinuation = async (
-      pendingResult: HarnessV1PendingToolResult,
-      continuation: ToolResultPart,
-    ): Promise<void> => {
-      const result = unwrapToolResultOutput(continuation);
-      onToolResultSettled(pendingResult.toolCallId);
-      pendingResultsByToolCallId.delete(pendingResult.toolCallId);
-      settledHostToolCallIds.add(pendingResult.toolCallId);
-      await control.submitToolResult({
-        toolCallId: pendingResult.toolCallId,
-        output: result.output,
-        isError: result.isError,
-        toolResult: {
-          ...continuation,
-          toolName: pendingResult.toolName,
-          ...(continuation.providerOptions == null &&
-          pendingResult.providerOptions != null
-            ? { providerOptions: pendingResult.providerOptions }
-            : {}),
-        },
-      });
-    };
     const enqueueHostToolOutcome = (options: {
       toolCall: ToolCallTextStreamPart;
       outcome: HostToolOutcome;
@@ -596,6 +574,68 @@ export function runPrompt<
         error: options.outcome.error,
       } as TextStreamPart<TOOLS>);
     };
+    const submitToolResult: HarnessV1PromptControl['submitToolResult'] =
+      async submission => {
+        if (!input.isTurnSuspending?.()) {
+          return control.submitToolResult(submission);
+        }
+        const toolCall =
+          rawToolCallsByToolCallId.get(submission.toolCallId) ??
+          pendingResultsByToolCallId.get(submission.toolCallId) ??
+          pendingToolApprovals.find(
+            approval => approval.toolCallId === submission.toolCallId,
+          );
+        if (toolCall == null) {
+          throw new Error(
+            `Unknown suspended tool call '${submission.toolCallId}'.`,
+          );
+        }
+        const { toolCallId, ...completedResult } = submission;
+        onPendingToolResult({
+          toolCallId,
+          toolName: toolCall.toolName,
+          input: toolCall.input,
+          completedResult,
+        });
+        const parsed = toolCallsByToolCallId.get(toolCallId);
+        if (parsed != null && !settledHostToolCallIds.has(toolCallId)) {
+          bufferedToolOutcomes.push(() =>
+            enqueueHostToolOutcome({
+              toolCall: parsed,
+              outcome: submission.isError
+                ? { ok: false, error: submission.output }
+                : { ok: true, output: submission.output },
+            }),
+          );
+        }
+      };
+    const processPendingToolResultContinuation = async (
+      pendingResult: HarnessV1PendingToolResult,
+      continuation: ToolResultPart | undefined,
+    ): Promise<void> => {
+      const submission =
+        continuation == null
+          ? pendingResult.completedResult
+          : {
+              ...unwrapToolResultOutput(continuation),
+              toolResult: {
+                ...continuation,
+                toolName: pendingResult.toolName,
+                ...(continuation.providerOptions == null &&
+                pendingResult.providerOptions != null
+                  ? { providerOptions: pendingResult.providerOptions }
+                  : {}),
+              },
+            };
+      if (submission == null) return;
+      settledHostToolCallIds.add(pendingResult.toolCallId);
+      onToolResultSettled(pendingResult.toolCallId);
+      await submitToolResult({
+        toolCallId: pendingResult.toolCallId,
+        ...submission,
+      });
+      pendingResultsByToolCallId.delete(pendingResult.toolCallId);
+    };
     const processPendingApprovalContinuation = async (
       approval: HarnessV1PendingToolApproval,
       continuation: ToolApprovalResponse,
@@ -643,7 +683,7 @@ export function runPrompt<
 
       settledHostToolCallIds.add(approval.toolCallId);
       if (!continuation.approved) {
-        await control.submitToolResult({
+        await submitToolResult({
           toolCallId: approval.toolCallId,
           output: {
             type: 'execution-denied',
@@ -664,7 +704,7 @@ export function runPrompt<
         wrappedExecuteTool: lifecycle.executeTool,
         sandboxSession: input.sandboxSession,
         abortSignal: input.abortSignal,
-        control,
+        submitToolResult,
         onPreliminaryResult: preliminaryOutput => {
           const stripped = stripWorkDir(
             {
@@ -727,12 +767,12 @@ export function runPrompt<
         const continuation = continuationsByToolCallId.get(
           pendingResult.toolCallId,
         );
-        if (continuation != null) {
+        if (continuation != null || pendingResult.completedResult != null) {
           await processPendingToolResultContinuation(
             pendingResult,
             continuation,
           );
-          closingResumedStep = true;
+          if (pendingResult.completedResult == null) closingResumedStep = true;
         }
       }
 
@@ -1083,7 +1123,7 @@ export function runPrompt<
                 toolName: toolCall.toolName,
               }),
             };
-            await control.submitToolResult({
+            await submitToolResult({
               toolCallId: toolCall.toolCallId,
               output,
             });
@@ -1130,7 +1170,7 @@ export function runPrompt<
               type: 'execution-denied',
               reason: customToolApprovalDecision.reason,
             };
-            await control.submitToolResult({
+            await submitToolResult({
               toolCallId: toolCall.toolCallId,
               output,
             });
@@ -1223,7 +1263,7 @@ export function runPrompt<
                 wrappedExecuteTool: lifecycle.executeTool,
                 sandboxSession: input.sandboxSession,
                 abortSignal: input.abortSignal,
-                control,
+                submitToolResult,
                 onPreliminaryResult: preliminaryOutput => {
                   /*
                    * Project a `yield`ed value as a preliminary AI SDK
@@ -1277,6 +1317,7 @@ export function runPrompt<
       await waitForOutstandingHostToolExecutions();
       const isTurnSuspending = input.isTurnSuspending?.() === true;
       if (isTurnSuspending) {
+        await publishToolExecutions();
         if (finalFinish == null) {
           /*
            * A timed slice may stop in the middle of a model step. Its partial
@@ -1388,7 +1429,7 @@ async function maybeExecuteHostTool<TOOLS extends ToolSet>(input: {
   wrappedExecuteTool: TurnLifecycle<ToolSet, Context>['executeTool'];
   sandboxSession: SandboxSession;
   abortSignal: AbortSignal | undefined;
-  control: HarnessV1PromptControl;
+  submitToolResult: HarnessV1PromptControl['submitToolResult'];
   /**
    * Called for each value a generator `execute` `yield`s before its last. The
    * caller surfaces these as preliminary `tool-result` parts on the consumer
@@ -1440,13 +1481,13 @@ async function maybeExecuteHostTool<TOOLS extends ToolSet>(input: {
       },
     });
 
-    await input.control.submitToolResult({
+    await input.submitToolResult({
       toolCallId: input.event.toolCallId,
       output,
     });
     return { executed: true, outcome: { ok: true, output } };
   } catch (err) {
-    await input.control.submitToolResult({
+    await input.submitToolResult({
       toolCallId: input.event.toolCallId,
       output: { error: String(err) },
       isError: true,

package/src/utils/index.ts

@@ -13,6 +13,18 @@ export {
 export { classifyDiskLog, type DiskLogRecoveryMode } from './classify-disk-log';
 export { getAiGatewayAuthFromEnv } from './ai-gateway-auth';
 export { isHarnessAuthenticationEnvironment } from './authentication-environment';
+export { getJwtExpiresAt, parseJwtPayload } from './native-subscription/jwt';
+export { readLinuxSecretServicePassword } from './native-subscription/linux-secret-service';
+export { readMacOSKeychainPassword } from './native-subscription/macos-keychain';
+export { shouldResolveNativeSubscription } from './native-subscription/should-resolve-native';
+export { readWindowsCredentialManagerPassword } from './native-subscription/windows-credential-manager';
+export {
+  isAccessTokenExpiringSoon,
+  refreshOAuthAccessToken,
+  type OAuthCredential,
+  type RefreshOAuthAccessTokenResult,
+} from './oauth-access-token';
+export { isLinux, isMacOS, isWindows } from './os';
 export {
   applyCredentialForwarding,
   createSandboxCredentialEnvironment,

package/src/utils/native-subscription/jwt.ts

@@ -0,0 +1,31 @@
+import { isRecord, safeParseJSON } from '@ai-sdk/provider-utils';
+
+export async function parseJwtPayload({
+  token,
+}: {
+  token: string;
+}): Promise<Readonly<Record<string, unknown>> | undefined> {
+  const segments = token.split('.');
+  if (segments.length !== 3) return undefined;
+
+  try {
+    const parsed = await safeParseJSON({
+      text: Buffer.from(segments[1], 'base64url').toString('utf8'),
+    });
+    return parsed.success && isRecord(parsed.value) ? parsed.value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function getJwtExpiresAt({
+  token,
+}: {
+  token: string;
+}): Promise<number | undefined> {
+  const payload = await parseJwtPayload({ token });
+  const expiresAt = payload?.exp;
+  return typeof expiresAt === 'number' && Number.isFinite(expiresAt)
+    ? expiresAt * 1000
+    : undefined;
+}

package/src/utils/native-subscription/linux-secret-service.ts

@@ -0,0 +1,23 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export async function readLinuxSecretServicePassword({
+  attributes,
+}: {
+  attributes: Readonly<Record<string, string>>;
+}): Promise<string | undefined> {
+  try {
+    const result = await execFileAsync('secret-tool', [
+      'lookup',
+      ...Object.entries(attributes).flatMap(([attribute, value]) => [
+        attribute,
+        value,
+      ]),
+    ]);
+    return result.stdout || undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/utils/native-subscription/macos-keychain.ts

@@ -0,0 +1,26 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export async function readMacOSKeychainPassword({
+  service,
+  account,
+}: {
+  service: string;
+  account: string;
+}): Promise<string | undefined> {
+  try {
+    const result = await execFileAsync('/usr/bin/security', [
+      'find-generic-password',
+      '-s',
+      service,
+      '-a',
+      account,
+      '-w',
+    ]);
+    return result.stdout.trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/utils/native-subscription/should-resolve-native.ts

@@ -0,0 +1,18 @@
+import type { HarnessV1Authentication } from '../../v1/harness-authentication';
+import { getAiGatewayAuthFromEnv } from '../ai-gateway-auth';
+
+export function shouldResolveNativeSubscription({
+  auth,
+  env,
+  hasDirectCredential,
+}: {
+  auth: Extract<HarnessV1Authentication, string> | undefined;
+  env: Readonly<Record<string, string | undefined>>;
+  hasDirectCredential: boolean;
+}): boolean {
+  return (
+    auth !== 'ai-gateway' &&
+    !hasDirectCredential &&
+    (auth === 'direct' || getAiGatewayAuthFromEnv({ env }).apiKey == null)
+  );
+}

package/src/utils/native-subscription/windows-credential-manager.ts

@@ -0,0 +1,61 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+const credentialManagerSource = `
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class AISDKCredentialManager {
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  public struct Credential {
+    public UInt32 Flags; public UInt32 Type; public string TargetName;
+    public string Comment; public System.Runtime.InteropServices.ComTypes.FILETIME LastWritten;
+    public UInt32 CredentialBlobSize; public IntPtr CredentialBlob;
+    public UInt32 Persist; public UInt32 AttributeCount; public IntPtr Attributes;
+    public string TargetAlias; public string UserName;
+  }
+  [DllImport("advapi32.dll", EntryPoint = "CredReadW", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern bool CredRead(string target, UInt32 type, UInt32 flags, out IntPtr credential);
+  [DllImport("advapi32.dll", SetLastError = true)] static extern void CredFree(IntPtr credential);
+  public static string Read(string target) {
+    IntPtr pointer;
+    if (!CredRead(target, 1, 0, out pointer)) return null;
+    try {
+      Credential value = Marshal.PtrToStructure<Credential>(pointer);
+      byte[] bytes = new byte[value.CredentialBlobSize];
+      Marshal.Copy(value.CredentialBlob, bytes, 0, bytes.Length);
+      return Encoding.Unicode.GetString(bytes);
+    } finally { CredFree(pointer); }
+  }
+}`;
+
+export async function readWindowsCredentialManagerPassword({
+  targetName,
+}: {
+  targetName: string;
+}): Promise<string | undefined> {
+  try {
+    const result = await execFileAsync(
+      'powershell.exe',
+      [
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        `Add-Type -TypeDefinition $env:AI_SDK_WINDOWS_CREDENTIAL_MANAGER_SOURCE; $value = [AISDKCredentialManager]::Read($env:AI_SDK_WINDOWS_CREDENTIAL_MANAGER_TARGET); if ($null -ne $value) { [Console]::Out.Write($value) }`,
+      ],
+      {
+        env: {
+          ...process.env,
+          AI_SDK_WINDOWS_CREDENTIAL_MANAGER_SOURCE: credentialManagerSource,
+          AI_SDK_WINDOWS_CREDENTIAL_MANAGER_TARGET: targetName,
+        },
+        windowsHide: true,
+      },
+    );
+    return result.stdout || undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/utils/oauth-access-token.ts

@@ -0,0 +1,129 @@
+import { isRecord, safeParseJSON } from '@ai-sdk/provider-utils';
+import { getJwtExpiresAt } from './native-subscription/jwt';
+
+const DEFAULT_REFRESH_WINDOW_MS = 300_000;
+
+export type OAuthCredential = {
+  readonly accessToken: string;
+  readonly refreshToken: string;
+  readonly expiresAt: number;
+};
+
+export type RefreshOAuthAccessTokenResult = {
+  readonly accessToken: string;
+  readonly expiresAt: number;
+  readonly refreshToken?: string;
+};
+
+export function isAccessTokenExpiringSoon({
+  expiresAt,
+  now = Date.now(),
+  refreshWindowMs = DEFAULT_REFRESH_WINDOW_MS,
+}: {
+  readonly expiresAt: number;
+  readonly now?: number;
+  readonly refreshWindowMs?: number;
+}): boolean {
+  return expiresAt <= now + refreshWindowMs;
+}
+
+export async function refreshOAuthAccessToken({
+  tokenUrl,
+  clientId,
+  refreshToken,
+  requestFormat = 'form',
+  headers,
+  fetch: fetchImplementation = globalThis.fetch,
+}: {
+  readonly tokenUrl: string;
+  readonly clientId: string;
+  readonly refreshToken: string;
+  readonly requestFormat?: 'json' | 'form';
+  readonly headers?: Record<string, string>;
+  readonly fetch?: typeof globalThis.fetch;
+}): Promise<RefreshOAuthAccessTokenResult> {
+  const values = {
+    grant_type: 'refresh_token',
+    client_id: clientId,
+    refresh_token: refreshToken,
+  };
+  const response = await fetchImplementation(tokenUrl, {
+    method: 'POST',
+    headers: {
+      'content-type':
+        requestFormat === 'json'
+          ? 'application/json'
+          : 'application/x-www-form-urlencoded',
+      ...headers,
+    },
+    body:
+      requestFormat === 'json'
+        ? JSON.stringify(values)
+        : new URLSearchParams(values).toString(),
+  });
+
+  const responseText = await response.text();
+  if (!response.ok) {
+    throw new Error(
+      `OAuth access token refresh failed with status ${response.status}.`,
+    );
+  }
+
+  const parsed = await safeParseJSON({ text: responseText });
+  if (!parsed.success || !isRecord(parsed.value)) {
+    throw new Error('OAuth access token refresh returned invalid JSON.');
+  }
+
+  const accessToken = parsed.value.access_token;
+  if (typeof accessToken !== 'string' || accessToken.length === 0) {
+    throw new Error(
+      'OAuth access token refresh response is missing access_token.',
+    );
+  }
+
+  const expiresAt = await resolveExpiresAt({
+    accessToken,
+    expiresIn: parsed.value.expires_in,
+  });
+  const rotatedRefreshToken = parsed.value.refresh_token;
+  if (
+    rotatedRefreshToken != null &&
+    (typeof rotatedRefreshToken !== 'string' ||
+      rotatedRefreshToken.length === 0)
+  ) {
+    throw new Error(
+      'OAuth access token refresh response contains an invalid refresh_token.',
+    );
+  }
+
+  return {
+    accessToken,
+    expiresAt,
+    ...(typeof rotatedRefreshToken === 'string'
+      ? { refreshToken: rotatedRefreshToken }
+      : {}),
+  };
+}
+
+async function resolveExpiresAt({
+  accessToken,
+  expiresIn,
+}: {
+  accessToken: string;
+  expiresIn: unknown;
+}): Promise<number> {
+  if (
+    typeof expiresIn === 'number' &&
+    Number.isFinite(expiresIn) &&
+    expiresIn >= 0
+  ) {
+    return Date.now() + expiresIn * 1000;
+  }
+
+  const jwtExpiresAt = await getJwtExpiresAt({ token: accessToken });
+  if (jwtExpiresAt != null) return jwtExpiresAt;
+
+  throw new Error(
+    'OAuth access token refresh response does not include a usable expiry.',
+  );
+}

package/src/utils/os.ts

@@ -0,0 +1,11 @@
+export function isMacOS(platform: NodeJS.Platform): boolean {
+  return platform === 'darwin';
+}
+
+export function isLinux(platform: NodeJS.Platform): boolean {
+  return platform === 'linux';
+}
+
+export function isWindows(platform: NodeJS.Platform): boolean {
+  return platform === 'win32';
+}