@ai-sdk/harness-claude-code 1.0.121 → 1.0.122

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-claude-code",
-  "version": "1.0.121",
+  "version": "1.0.122",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.117",
+    "@ai-sdk/harness": "1.0.118",
     "@ai-sdk/provider-utils": "5.0.45",
     "ws": "^8.21.0"
   },

package/src/bridge/create-emit-stream-event.ts

@@ -35,7 +35,7 @@ export type ClaudeMessage = {
     };
   };
   message?: {
-    content?: ReadonlyArray<MessageBlock>;
+    content?: string | ReadonlyArray<MessageBlock>;
     usage?: Record<string, unknown>;
   };
   result?: string;
@@ -232,11 +232,12 @@ export function createEmitStreamEvent({
       return;
     }
 
-    if (type === 'assistant' && msg.message?.content) {
-      const usage = toUsageRecord(msg.message.usage);
+    const messageContent = msg.message?.content;
+    if (type === 'assistant' && Array.isArray(messageContent)) {
+      const usage = toUsageRecord(msg.message?.usage);
       const toolUseIds: string[] = [];
       let opensStep = false;
-      for (const block of msg.message.content) {
+      for (const block of messageContent) {
         if (
           block.type === 'tool_use' &&
           typeof block.id === 'string' &&
@@ -287,14 +288,14 @@ export function createEmitStreamEvent({
       return;
     }
 
-    if (type === 'user' && msg.message?.content) {
-      const toolResultBlocks = msg.message.content.filter(
+    if (type === 'user' && Array.isArray(messageContent)) {
+      const toolResultBlocks = messageContent.filter(
         block => block.type === 'tool_result',
       );
       const toolUseResult =
         toolResultBlocks.length === 1 ? msg.tool_use_result : undefined;
 
-      for (const block of msg.message.content) {
+      for (const block of messageContent) {
         if (
           block.type === 'tool_result' &&
           typeof block.tool_use_id === 'string'

package/src/bridge/index.ts

@@ -51,7 +51,7 @@ import {
   mapUsage,
   type ClaudeMessage,
 } from './create-emit-stream-event';
-import { jsonSchemaToZodShape } from './json-schema-to-zod';
+import { jsonSchemaToZodObject } from './json-schema-to-zod';
 import {
   resolveInactiveNativeTools,
   resolveNativeTools,
@@ -380,11 +380,12 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       version: '1.0.0',
     });
     for (const tool of start.tools) {
-      const shape = jsonSchemaToZodShape(tool.inputSchema);
-      server.tool(
+      server.registerTool(
         tool.name,
-        tool.description ?? '',
-        shape,
+        {
+          description: tool.description ?? '',
+          inputSchema: jsonSchemaToZodObject(tool.inputSchema),
+        },
         async (
           ...handlerArgs: [
             Record<string, unknown>,

package/src/bridge/json-schema-to-zod.ts

@@ -6,6 +6,7 @@ export type JsonSchemaObject = {
   type?: string | string[];
   description?: string;
   properties?: Record<string, JsonSchemaObject>;
+  additionalProperties?: boolean | JsonSchemaObject;
   required?: string[];
   items?: JsonSchemaObject | JsonSchemaObject[];
   enum?: unknown[];
@@ -17,9 +18,21 @@ export type JsonSchemaObject = {
 
 type ZodShape = Record<string, z.ZodTypeAny>;
 
-export function jsonSchemaToZodShape(input: unknown): ZodShape {
+export function jsonSchemaToZodObject(input: unknown) {
   const schema = isJsonSchemaObject(input) ? input : {};
-  return toZodShape(schema);
+  return toZodObject(schema);
+}
+
+function toZodObject(schema: JsonSchemaObject) {
+  const object = z.object(toZodShape(schema));
+  if (schema.additionalProperties === false) return object.strict();
+
+  // JSON Schema allows additional properties by default; Zod strips them.
+  return object.catchall(
+    isJsonSchemaObject(schema.additionalProperties)
+      ? toZodType(schema.additionalProperties)
+      : z.unknown(),
+  );
 }
 
 function toZodShape(schema: JsonSchemaObject | undefined): ZodShape {
@@ -71,7 +84,7 @@ function zodForType(schema: JsonSchemaObject): z.ZodTypeAny {
         Array.isArray(schema.items) ? z.any() : toZodType(schema.items),
       );
     case 'object':
-      return z.object(toZodShape(schema));
+      return toZodObject(schema);
     case 'null':
       return z.null();
     default:

package/src/claude-code-harness.ts

@@ -38,10 +38,12 @@ import {
   resolveSandboxHomeDir,
   SandboxChannel,
   shellQuote,
+  sleep,
   warnCredentialBrokeringUnavailable,
   waitForBridgeReady,
   withBridgeToken,
   writeSkills,
+  type SandboxChannelReconnectOptions,
 } from '@ai-sdk/harness/utils';
 import {
   safeParseJSON,
@@ -128,6 +130,13 @@ export type ClaudeCodeHarnessSettings = {
   readonly portEndpoint?: HarnessV1PortEndpoint;
   /** Maximum milliseconds to wait for the bridge to advertise its port. Defaults to 120000. */
   readonly startupTimeoutMs?: number;
+  /**
+   * Configures reconnection attempts after an established bridge connection
+   * drops. The reconnect window includes connection establishment and
+   * backoff delays. Defaults to 30 seconds with exponential backoff from 50
+   * milliseconds up to 2 seconds.
+   */
+  readonly reconnect?: SandboxChannelReconnectOptions;
   /**
    * Creates the authentication token used by the sandbox bridge. Defaults to
    * a random 32-byte hexadecimal token.
@@ -964,10 +973,16 @@ export function createClaudeCode(
       // (re)connect: open the socket, then wait for `bridge-hello` so the
       // end-to-end link is proven live before any frame is sent.
       const buildConnect =
-        (endpoint: HarnessV1PortEndpoint) => async (): Promise<WebSocket> => {
+        (endpoint: HarnessV1PortEndpoint) =>
+        async ({
+          abortSignal,
+        }: {
+          abortSignal: AbortSignal;
+        }): Promise<WebSocket> => {
           return openBridgeWebSocket({
             endpoint,
             timeoutMs,
+            abortSignal,
             onHello: supportsResponses => {
               supportsUserMessageResponses = supportsResponses;
             },
@@ -999,6 +1014,7 @@ export function createClaudeCode(
             initialLastSeenEventId: coords.lastSeenEventId,
             onDiagnostic,
             onBridgeError,
+            reconnect: settings.reconnect,
           });
           await attachChannel.open(isContinue ? { resume: true } : undefined);
           return createSession({
@@ -1144,6 +1160,7 @@ export function createClaudeCode(
         outboundSchema: outboundMessageSchema,
         onDiagnostic,
         onBridgeError,
+        reconnect: settings.reconnect,
         // In replay mode the respawned bridge reloaded the finished turn from
         // disk; seed the cursor and resume so it streams the tail (incl.
         // `finish`) rather than starting empty.
@@ -1270,14 +1287,23 @@ function openWebSocketAndWaitForBridgeHello({
   endpoint,
   openTimeoutMs,
   getHelloTimeoutMs,
+  abortSignal,
   onHello,
 }: {
   endpoint: HarnessV1PortEndpoint;
   openTimeoutMs: number;
   getHelloTimeoutMs: () => number;
+  abortSignal: AbortSignal;
   onHello: (supportsUserMessageResponses: boolean) => void;
 }): Promise<WebSocket> {
   return new Promise<WebSocket>((resolve, reject) => {
+    const abortReason = () =>
+      abortSignal.reason ?? new Error('WebSocket connection aborted');
+    if (abortSignal.aborted) {
+      reject(abortReason());
+      return;
+    }
+
     const ws = new WebSocket(endpoint.url, {
       headers: endpoint.headers == null ? undefined : { ...endpoint.headers },
     });
@@ -1286,6 +1312,7 @@ function openWebSocketAndWaitForBridgeHello({
     let settled = false;
     let openTimer: ReturnType<typeof setTimeout> | undefined;
     let helloTimer: ReturnType<typeof setTimeout> | undefined;
+    let onAbort: (() => void) | undefined;
 
     const cleanup = ({
       keepTerminationListeners = false,
@@ -1296,6 +1323,9 @@ function openWebSocketAndWaitForBridgeHello({
       if (helloTimer) clearTimeout(helloTimer);
       ws.off('open', onOpen);
       ws.off('message', onMessage);
+      if (onAbort != null) {
+        abortSignal.removeEventListener('abort', onAbort);
+      }
       if (!keepTerminationListeners) {
         ws.off('close', onClose);
         ws.off('error', onError);
@@ -1374,6 +1404,7 @@ function openWebSocketAndWaitForBridgeHello({
       cleanup();
     };
     const onError = (err: Error) => settle(err);
+    onAbort = () => settle(abortReason());
     openTimer = setTimeout(
       () =>
         settle(new Error(`WebSocket open timed out after ${openTimeoutMs}ms`)),
@@ -1384,23 +1415,26 @@ function openWebSocketAndWaitForBridgeHello({
     ws.on('message', onMessage);
     ws.on('close', onClose);
     ws.on('error', onError);
+    abortSignal.addEventListener('abort', onAbort, { once: true });
   });
 }
 
 async function openBridgeWebSocket({
   endpoint,
   timeoutMs,
+  abortSignal,
   onHello,
 }: {
   endpoint: HarnessV1PortEndpoint;
   timeoutMs: number;
+  abortSignal: AbortSignal;
   onHello: (supportsUserMessageResponses: boolean) => void;
 }): Promise<WebSocket> {
   const deadline = Date.now() + timeoutMs;
   let attempt = 0;
   let lastError: unknown;
 
-  while (Date.now() < deadline) {
+  while (!abortSignal.aborted && Date.now() < deadline) {
     attempt++;
     try {
       const remaining = Math.max(1, deadline - Date.now());
@@ -1409,16 +1443,27 @@ async function openBridgeWebSocket({
         openTimeoutMs: Math.min(10_000, remaining),
         getHelloTimeoutMs: () =>
           Math.min(5_000, Math.max(1, deadline - Date.now())),
+        abortSignal,
         onHello,
       });
     } catch (err) {
+      if (abortSignal.aborted) {
+        throw abortSignal.reason ?? new Error('WebSocket connection aborted');
+      }
       lastError = err;
       const remaining = deadline - Date.now();
       if (remaining <= 0) break;
-      await sleep(Math.min(250 * attempt, 1_000, remaining));
+      await sleep({
+        ms: Math.min(250 * attempt, 1_000, remaining),
+        abortSignal,
+      });
     }
   }
 
+  if (abortSignal.aborted) {
+    throw abortSignal.reason ?? new Error('WebSocket connection aborted');
+  }
+
   throw new Error(
     `claude-code bridge did not complete WebSocket handshake within ${timeoutMs}ms after ${attempt} attempt(s). Last error: ${formatUnknownError(lastError)}`,
   );
@@ -1437,13 +1482,6 @@ function webSocketMessageToString(raw: unknown): string {
   return String(raw);
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => {
-    const timer = setTimeout(resolve, ms);
-    timer.unref?.();
-  });
-}
-
 function formatUnknownError(error: unknown): string {
   if (error instanceof Error) return error.message;
   return String(error);