@ai-sdk/harness 1.0.74 → 1.0.76

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

@@ -14,6 +14,8 @@ import { generateId, type ToolSet } from '@ai-sdk/provider-utils';
  *   - tool-call events are not translated here — validation against the
  *     merged tool set is async and handled by `validateToolCall` in
  *     `run-prompt.ts`
+ *   - a failed `tool-result` from a provider-executed tool becomes a
+ *     `tool-error` (see `isProviderExecuted`)
  *   - the harness `raw` part is forwarded as the AI SDK `raw` part
  *
  * Returns an array of zero or more AI SDK parts. Most harness events project
@@ -26,6 +28,17 @@ import { generateId, type ToolSet } from '@ai-sdk/provider-utils';
  */
 export function translateStreamPart<TOOLS extends ToolSet>(
   event: HarnessV1StreamPart,
+  options: {
+    /**
+     * Whether the tool call that produced this event ran inside the harness
+     * runtime. Host tools travel the same `tool-result` events and their
+     * failures are echoed back with `isError`, so the event alone cannot say
+     * who ran the tool — only the originating `tool-call` can, and correlating
+     * the two is the caller's job. Omit the callback to treat every failure as
+     * provider-executed.
+     */
+    isProviderExecuted?: (toolCallId: string) => boolean;
+  } = {},
 ): ReadonlyArray<TextStreamPart<TOOLS>> {
   switch (event.type) {
     case 'stream-start':
@@ -101,6 +114,32 @@ export function translateStreamPart<TOOLS extends ToolSet>(
       return [];
 
     case 'tool-result':
+      if (
+        event.isError === true &&
+        (options.isProviderExecuted?.(event.toolCallId) ?? true)
+      ) {
+        /*
+         * `providerExecuted` decides whether the message survives:
+         * `toUIMessageChunk` forwards the real error text only for
+         * provider-executed errors, and replaces every other one with the
+         * generic `onError` string.
+         */
+        return [
+          {
+            type: 'tool-error',
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            input: undefined,
+            error: event.result,
+            providerExecuted: true,
+            ...(event.dynamic !== undefined ? { dynamic: event.dynamic } : {}),
+            ...(event.providerMetadata !== undefined
+              ? { providerMetadata: event.providerMetadata }
+              : {}),
+          } as TextStreamPart<TOOLS>,
+        ];
+      }
+
       return [
         {
           type: 'tool-result',

package/src/agent/prepare-harness-sandbox-template.ts

@@ -1,4 +1,4 @@
-import type { HarnessV1SandboxProvider } from '../v1';
+import type { HarnessV1Bootstrap, HarnessV1SandboxProvider } from '../v1';
 import type { HarnessAgentAdapter } from './harness-agent-types';
 import type { HarnessAgentSandboxConfig } from './harness-agent-settings';
 import { applyBootstrapRecipe } from './internal/bootstrap-recipe';
@@ -31,9 +31,14 @@ export async function prepareHarnessSandboxTemplate(options: {
 }): Promise<void> {
   const sandboxConfig = options.sandboxConfig ?? {};
   validateSandboxBootstrapSettings(sandboxConfig);
-  const recipe = await options.harness.getBootstrap?.({
-    abortSignal: options.abortSignal,
-  });
+
+  const { harness, sandboxProvider, abortSignal } = options;
+
+  let recipe: HarnessV1Bootstrap | undefined;
+  if (harness.getBootstrap != null) {
+    recipe = await harness.getBootstrap({ abortSignal });
+  }
+
   const bootstrapPlan = await createSandboxBootstrapPlan({
     recipe,
     settings: sandboxConfig,
@@ -42,12 +47,15 @@ export async function prepareHarnessSandboxTemplate(options: {
     return;
   }
 
-  const sandboxSession = await options.sandboxProvider.createSession({
-    abortSignal: options.abortSignal,
+  const sandboxSession = await sandboxProvider.createSession({
+    abortSignal,
     identity: bootstrapPlan.identity,
     onFirstCreate: bootstrapPlan.onFirstCreate,
   });
 
+  // Unlike `prepareSandboxForHarness()` and `HarnessAgent.createSession()`, this function
+  // does not apply the agent-specific sandbox config, since the function is meant as a
+  // general harness utility, not for a concrete agent.
   try {
     if (bootstrapPlan.recipe != null && bootstrapPlan.recipeIdentity != null) {
       await applyBootstrapRecipe({
@@ -55,7 +63,7 @@ export async function prepareHarnessSandboxTemplate(options: {
         recipe: bootstrapPlan.recipe,
         identity: bootstrapPlan.recipeIdentity,
         defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
-        abortSignal: options.abortSignal,
+        abortSignal,
       });
     }
   } finally {

package/src/v1/harness-v1-sandbox-provider.ts

@@ -11,18 +11,6 @@ export interface HarnessV1SandboxProvider {
   readonly specificationVersion: 'harness-sandbox-v1';
   readonly providerId: string;
 
-  /**
-   * Pool of ports the consumer reserved on a caller-provided sandbox for
-   * concurrent harness sessions. The session manager leases one port per
-   * session and releases on stop or destroy.
-   *
-   * Only meaningful when the provider wraps a caller-provided sandbox
-   * (the caller pre-declared the ports). In create-new modes the provider
-   * mints a fresh sandbox per session, so no leasing is needed; providers
-   * leave this undefined.
-   */
-  readonly bridgePorts?: ReadonlyArray<number>;
-
   /**
    * Providers should throw `HarnessSandboxAuthenticationError` when sandbox
    * acquisition fails because credentials are missing, invalid, or not

package/src/agent/internal/bridge-port-registry.ts

@@ -1,52 +0,0 @@
-/**
- * Process-wide registry for bridge-port leases. Used when a sandbox provider
- * wraps a caller-provided sandbox with a pre-declared port pool — each
- * concurrent harness session leases one port from the pool, releases on
- * session stop or destroy. Multiple sessions on the same provider instance
- * share the same pool; different provider instances (even wrapping the same
- * underlying sandbox) get independent registries.
- *
- * Sized to the typical case: one provider object passed to N HarnessAgents.
- * Callers that need cross-process coordination must layer that on top.
- */
-
-type RegistryEntry = {
-  readonly pool: ReadonlyArray<number>;
-  readonly leases: Map<string, number>;
-};
-
-const registries = new WeakMap<object, RegistryEntry>();
-
-export function acquireBridgePort(options: {
-  poolKey: object;
-  pool: ReadonlyArray<number>;
-  sessionId: string;
-}): number {
-  let entry = registries.get(options.poolKey);
-  if (entry == null) {
-    entry = { pool: options.pool, leases: new Map() };
-    registries.set(options.poolKey, entry);
-  }
-  const existing = entry.leases.get(options.sessionId);
-  if (existing != null) return existing;
-
-  const leased = new Set(entry.leases.values());
-  for (const port of entry.pool) {
-    if (!leased.has(port)) {
-      entry.leases.set(options.sessionId, port);
-      return port;
-    }
-  }
-  throw new Error(
-    `No available bridge port — pool of ${entry.pool.length} ports is fully leased.`,
-  );
-}
-
-export function releaseBridgePort(options: {
-  poolKey: object;
-  sessionId: string;
-}): void {
-  const entry = registries.get(options.poolKey);
-  if (entry == null) return;
-  entry.leases.delete(options.sessionId);
-}