@ai-sdk/harness-claude-code 1.0.22 → 1.0.24

package/src/bridge/index.ts

@@ -89,6 +89,7 @@ const PUBLIC_TO_NATIVE: Readonly<Record<string, string>> = {
 };
 
 const PUBLIC_TOOL_NAMES = Object.keys(PUBLIC_TO_NATIVE);
+const UNRECOVERABLE_API_RETRY_STATUSES = new Set([401, 403, 404]);
 
 const NATIVE_TOOL_KINDS: Readonly<
   Record<string, 'readonly' | 'edit' | 'bash'>
@@ -151,40 +152,6 @@ function resolveInactiveNativeTools(start: StartMessage): string[] {
   return inactiveToolNames.map(name => toNativeName(name));
 }
 
-/*
- * The harness exposes a coarse `'off' | 'on' | 'adaptive'` thinking setting,
- * but the Claude Agent SDK's `thinking` option takes a structured
- * `ThinkingConfig` object. Passing the bare string silently disables extended
- * thinking (the SDK ignores the malformed value), so the model never emits
- * thinking blocks and no reasoning is streamed. Map to the SDK's shape:
- *   'adaptive' → { type: 'adaptive' }  (Claude decides depth; Opus 4.6+)
- *   'on'       → { type: 'enabled' }   (extended thinking always on)
- *   'off'      → { type: 'disabled' }
- *
- * `display: 'summarized'` is required for the model's reasoning to actually be
- * streamed: without it the thinking block arrives carrying only a signature
- * and empty `thinking_delta`s, so `reasoningText` comes back empty. We default
- * it on whenever thinking is enabled so reasoning is visible out of the box;
- * `'off'` (disabled) takes no display.
- */
-function toThinkingConfig(
-  thinking: 'off' | 'on' | 'adaptive' | undefined,
-):
-  | { type: 'adaptive' | 'enabled'; display: 'summarized' }
-  | { type: 'disabled' }
-  | undefined {
-  switch (thinking) {
-    case 'adaptive':
-      return { type: 'adaptive', display: 'summarized' };
-    case 'on':
-      return { type: 'enabled', display: 'summarized' };
-    case 'off':
-      return { type: 'disabled' };
-    default:
-      return undefined;
-  }
-}
-
 const args = parseArgs(argv.slice(2));
 const workdir = args.workdir;
 const bridgeStateDir = args.bridgeStateDir;
@@ -216,6 +183,7 @@ function createPermissionOptions(input: {
   inactiveNativeTools: readonly string[];
   turn: BridgeTurn;
   emit: Emit;
+  finishApprovalStep: (approvalId: string) => void;
   nativeToolCallNames: Map<string, string>;
   approvalRequestedToolUseIds: Set<string>;
 }): Record<string, unknown> {
@@ -271,6 +239,7 @@ function createPermissionOptions(input: {
         approvalId,
         toolCallId: approvalId,
       });
+      input.finishApprovalStep(approvalId);
 
       const decision = await input.turn.requestToolApproval(approvalId);
       return decision.approved
@@ -342,6 +311,33 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
    */
   const nativeToolCallNames = new Map<string, string>();
   const approvalRequestedToolUseIds = new Set<string>();
+  const partialBlocks = new Map<
+    number,
+    { id: string; kind: 'text' | 'thinking' }
+  >();
+  let stepUsage: Record<string, unknown> | undefined;
+  let pendingStepToolUseIds = new Set<string>();
+  let pendingStepUsage: Record<string, unknown> | undefined;
+  let stepOpen = false;
+
+  const emitFinishStep = (usage: Record<string, unknown> | undefined): void => {
+    emit({
+      type: 'finish-step',
+      finishReason: { unified: 'stop', raw: 'stop' },
+      usage: usage ?? defaultUsage(),
+    });
+    stepUsage = usage ?? stepUsage;
+    pendingStepUsage = undefined;
+    pendingStepToolUseIds = new Set();
+    stepOpen = false;
+  };
+
+  const closeStepIfReady = (): void => {
+    if (!stepOpen || pendingStepToolUseIds.size > 0 || partialBlocks.size > 0) {
+      return;
+    }
+    emitFinishStep(pendingStepUsage);
+  };
 
   /*
    * Tool-use ids that originated from the MCP server hosting user-supplied
@@ -416,6 +412,11 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     inactiveNativeTools,
     turn,
     emit,
+    finishApprovalStep: approvalId => {
+      stepOpen = true;
+      pendingStepToolUseIds.delete(approvalId);
+      closeStepIfReady();
+    },
     nativeToolCallNames,
     approvalRequestedToolUseIds,
   });
@@ -430,9 +431,7 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       ...(inactiveNativeTools.length > 0
         ? { disallowedTools: inactiveNativeTools }
         : {}),
-      ...(toThinkingConfig(start.thinking)
-        ? { thinking: toThinkingConfig(start.thinking) }
-        : {}),
+      thinking: start.thinking,
       includePartialMessages: true,
       // The `PostCompact` hook carries the compaction summary, which the
       // `compact_boundary` system message does not. Latch it for the unified
@@ -462,24 +461,24 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       abortSignal: abortCtl.signal,
     },
   });
+  turn.onInterrupt(() => q.interrupt());
 
-  let stepUsage: Record<string, unknown> | undefined;
+  let turnUsage: Record<string, unknown> | undefined;
   let totalCostUsd: number | undefined;
   let observedTerminalError: string | undefined;
   let emittedTerminalError = false;
   let emittedTerminalFinish = false;
   let streamStarted = false;
-  const partialBlocks = new Map<
-    number,
-    { id: string; kind: 'text' | 'thinking' }
-  >();
 
   const emitTerminalError = (message: string | undefined): void => {
     const normalized = message?.trim();
     if (!normalized || emittedTerminalError || emittedTerminalFinish) return;
     observedTerminalError = normalized;
     emittedTerminalError = true;
-    emit({ type: 'error', error: normalized });
+    turn.emitError({
+      error: normalized,
+      message: 'claude-code terminal error',
+    });
     queryInput.close();
     abortCtl.abort();
   };
@@ -488,10 +487,6 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     for await (const msg of q as AsyncIterable<ClaudeMessage>) {
       if (abortCtl.signal.aborted) break;
 
-      if (typeof msg.error === 'string' && msg.error.trim()) {
-        observedTerminalError = msg.error.trim();
-      }
-
       const type = msg.type;
 
       // Emit `stream-start` once, on the first message, carrying the model the
@@ -511,6 +506,27 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
         streamStarted = true;
       }
 
+      if (type === 'system' && msg.subtype === 'api_retry') {
+        if (
+          typeof msg.error_status === 'number' &&
+          UNRECOVERABLE_API_RETRY_STATUSES.has(msg.error_status)
+        ) {
+          emitTerminalError(
+            `HTTP ${msg.error_status}: ${
+              msg.error ?? 'provider request failed'
+            }`,
+          );
+          continue;
+        }
+
+        turn.emitWarning({ message: formatApiRetryWarning(msg) });
+        continue;
+      }
+
+      if (typeof msg.error === 'string' && msg.error.trim()) {
+        observedTerminalError = msg.error.trim();
+      }
+
       if (
         type === 'auth_status' &&
         typeof msg.error === 'string' &&
@@ -520,18 +536,6 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
         continue;
       }
 
-      if (
-        type === 'system' &&
-        msg.subtype === 'api_retry' &&
-        typeof msg.error_status === 'number' &&
-        [401, 403, 404].includes(msg.error_status)
-      ) {
-        emitTerminalError(
-          `HTTP ${msg.error_status}: ${msg.error ?? 'provider request failed'}`,
-        );
-        continue;
-      }
-
       if (
         type === 'system' &&
         msg.subtype === 'task_updated' &&
@@ -564,21 +568,29 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       }
 
       if (type === 'assistant' && msg.message?.content) {
+        const usage = mapUsage(msg.message.usage);
+        const toolUseIds: string[] = [];
+        let opensStep = false;
         for (const block of msg.message.content) {
           if (
             block.type === 'tool_use' &&
             typeof block.id === 'string' &&
             typeof block.name === 'string'
           ) {
+            toolUseIds.push(block.id);
             const mcpPrefix = 'mcp__harness-tools__';
             if (block.name.startsWith(mcpPrefix)) {
+              pendingStepToolUseIds.add(block.id);
               mcpToolUseIds.add(block.id);
+              opensStep = true;
               continue;
             }
             nativeToolCallNames.set(block.id, block.name);
             if (approvalRequestedToolUseIds.has(block.id)) {
               continue;
             }
+            pendingStepToolUseIds.add(block.id);
+            opensStep = true;
             emit({
               type: 'tool-call',
               toolCallId: block.id,
@@ -589,6 +601,10 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
             });
           }
         }
+        if (opensStep || toolUseIds.length === 0) {
+          stepOpen = true;
+          if (usage) pendingStepUsage = usage;
+        }
         continue;
       }
 
@@ -600,6 +616,7 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
           ) {
             if (mcpToolUseIds.has(block.tool_use_id)) {
               mcpToolUseIds.delete(block.tool_use_id);
+              pendingStepToolUseIds.delete(block.tool_use_id);
               continue;
             }
             approvalRequestedToolUseIds.delete(block.tool_use_id);
@@ -630,8 +647,10 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
               result,
               isError,
             });
+            pendingStepToolUseIds.delete(block.tool_use_id);
           }
         }
+        closeStepIfReady();
         continue;
       }
 
@@ -644,20 +663,11 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
           }
           const usage = msg.usage ?? msg.message?.usage;
           const harnessUsage = mapUsage(usage);
-          if (harnessUsage) stepUsage = harnessUsage;
+          if (harnessUsage) turnUsage = harnessUsage;
           if (typeof msg.total_cost_usd === 'number') {
             totalCostUsd = (totalCostUsd ?? 0) + msg.total_cost_usd;
           }
-          const metadata =
-            typeof msg.total_cost_usd === 'number'
-              ? { 'claude-code': { costUsd: msg.total_cost_usd } }
-              : undefined;
-          emit({
-            type: 'finish-step',
-            finishReason: { unified: 'stop', raw: 'stop' },
-            usage: harnessUsage ?? defaultUsage(),
-            ...(metadata ? { harnessMetadata: metadata } : {}),
-          });
+          if (stepOpen) emitFinishStep(harnessUsage ?? pendingStepUsage);
           queryInput.close();
           break;
         } else {
@@ -673,7 +683,7 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     }
   } catch (err) {
     if (!(abortCtl.signal.aborted && emittedTerminalError)) {
-      emit({ type: 'error', error: serialiseError(err) });
+      turn.emitError({ error: err, message: 'claude-code turn failed' });
     }
     return;
   } finally {
@@ -686,7 +696,7 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   emit({
     type: 'finish',
     finishReason: { unified: 'stop', raw: 'stop' },
-    totalUsage: stepUsage ?? defaultUsage(),
+    totalUsage: turnUsage ?? stepUsage ?? defaultUsage(),
     ...(totalCostUsd !== undefined
       ? { harnessMetadata: { 'claude-code': { costUsd: totalCostUsd } } }
       : {}),
@@ -697,7 +707,10 @@ type ClaudeMessage = {
   type?: string;
   subtype?: string;
   error?: string;
-  error_status?: number;
+  error_status?: number | null;
+  attempt?: number;
+  max_retries?: number;
+  retry_delay_ms?: number;
   patch?: { status?: string; error?: string };
   compact_metadata?: {
     trigger: 'manual' | 'auto';
@@ -720,6 +733,25 @@ type ClaudeMessage = {
   total_cost_usd?: number;
 };
 
+function formatApiRetryWarning(msg: ClaudeMessage): string {
+  const details: string[] = [];
+  if (typeof msg.attempt === 'number') {
+    const maxRetries =
+      typeof msg.max_retries === 'number' ? `/${msg.max_retries}` : '';
+    details.push(`attempt ${msg.attempt}${maxRetries}`);
+  }
+  if (typeof msg.error_status === 'number') {
+    details.push(`HTTP ${msg.error_status}`);
+  }
+  if (typeof msg.retry_delay_ms === 'number') {
+    details.push(`retrying in ${msg.retry_delay_ms}ms`);
+  }
+  if (msg.error) details.push(msg.error);
+  return details.length > 0
+    ? `Claude Code API retry: ${details.join('; ')}`
+    : 'Claude Code API retry';
+}
+
 function handleStreamEvent(
   event: ClaudeMessage['event'] | undefined,
   partialBlocks: Map<number, { id: string; kind: 'text' | 'thinking' }>,
@@ -954,13 +986,6 @@ function parseArgs(args: string[]): {
   return out;
 }
 
-function serialiseError(err: unknown): unknown {
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message, stack: err.stack };
-  }
-  return err;
-}
-
 function emitFatal(message: string): never {
   stdout.write(JSON.stringify({ type: 'bridge-fatal', message }) + '\n');
   process.exit(1);

package/src/claude-code-bridge-protocol.ts

@@ -16,8 +16,22 @@ import { z } from 'zod/v4';
 export const outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
 export type OutboundMessage = z.infer<typeof outboundMessageSchema>;
 
+const thinkingDisplaySchema = z.enum(['summarized', 'omitted']).optional();
+
+const thinkingSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('adaptive'),
+    display: thinkingDisplaySchema,
+  }),
+  z.object({
+    type: z.literal('enabled'),
+    display: thinkingDisplaySchema,
+  }),
+  z.object({ type: z.literal('disabled') }),
+]);
+
 export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
-  thinking: z.enum(['off', 'on', 'adaptive']).optional(),
+  thinking: thinkingSchema,
   maxTurns: z.number().optional(),
   skills: z.array(z.string()).optional(),
   // Resume signal. When true, the bridge passes `{ continue: true }` to the

package/src/claude-code-harness.ts

@@ -22,6 +22,10 @@ import {
 } from '@ai-sdk/harness';
 import {
   classifyDiskLog,
+  createBridgeErrorHandler,
+  createBridgeStartupError,
+  drainBridgeProcessStream,
+  forwardBridgeProcessStream,
   markBridgeStarting,
   resolveSandboxHomeDir,
   SandboxChannel,
@@ -45,6 +49,7 @@ import {
   type InboundMessage,
   type OutboundMessage,
 } from './claude-code-bridge-protocol';
+import type { ClaudeCodeThinkingConfig } from './claude-code-thinking';
 import { VERSION } from './version';
 
 type ClaudeCodeChannel = SandboxChannel<OutboundMessage, InboundMessage>;
@@ -68,10 +73,10 @@ export type ClaudeCodeHarnessSettings = {
    */
   readonly maxTurns?: number;
   /**
-   * Controls extended-thinking behavior. `'off'` disables thinking,
-   * `'on'` forces it on, `'adaptive'` lets the runtime decide.
+   * Controls extended-thinking behavior and whether reasoning is summarized or
+   * omitted. Defaults to `{ type: 'adaptive', display: 'summarized' }`.
    */
-  readonly thinking?: 'off' | 'on' | 'adaptive';
+  readonly thinking?: ClaudeCodeThinkingConfig;
   /**
    * Override the port the bridge binds inside the sandbox. By default the
    * adapter uses the first port the sandbox declares via `sandbox.ports`.
@@ -416,6 +421,10 @@ export function createClaudeCode(
   settings: ClaudeCodeHarnessSettings = {},
 ): HarnessV1<typeof CLAUDE_CODE_BUILTIN_TOOLS> {
   let cachedBootstrap: HarnessV1Bootstrap | undefined;
+  const thinking = settings.thinking ?? {
+    type: 'adaptive',
+    display: 'summarized',
+  };
 
   return {
     specificationVersion: 'harness-v1',
@@ -480,6 +489,10 @@ export function createClaudeCode(
               }),
             )
         : undefined;
+      const onBridgeError = createBridgeErrorHandler({
+        harnessId: 'claude-code',
+        sessionId: startOpts.sessionId,
+      });
 
       // Builds the `connect` thunk a `SandboxChannel` re-invokes on every
       // (re)connect: open the socket, then wait for `bridge-hello` so the
@@ -508,6 +521,7 @@ export function createClaudeCode(
             outboundSchema: outboundMessageSchema,
             initialLastSeenEventId: coords.lastSeenEventId,
             onDiagnostic,
+            onBridgeError,
           });
           await attachChannel.open(isContinue ? { resume: true } : undefined);
           return createSession({
@@ -519,7 +533,7 @@ export function createClaudeCode(
             proc: undefined,
             model: settings.model,
             maxTurns: settings.maxTurns,
-            thinking: settings.thinking,
+            thinking,
             isResume: true,
             continueOnFirstPrompt: false,
             rerunContinue: false,
@@ -625,14 +639,10 @@ export function createClaudeCode(
       });
 
       const bridgeStartupStderr: string[] = [];
-      /*
-       * Bridge stderr is the only diagnostic channel for sandbox-side crashes
-       * and startup failures. Start forwarding before `bridge-ready`, otherwise
-       * module-resolution, auth, and syntax errors can be lost behind the
-       * generic startup failure below.
-       */
-      const bridgeStartupStderrDone = forwardBridgeStderr({
+      const bridgeStartupStderrDone = forwardBridgeProcessStream({
         stream: proc.stderr,
+        streamName: 'stderr',
+        source: 'claude-code',
         collectTail: bridgeStartupStderr,
       });
       void bridgeStartupStderrDone;
@@ -660,7 +670,7 @@ export function createClaudeCode(
             stderrDone: bridgeStartupStderrDone,
           }),
       });
-      void drainRest(proc.stdout);
+      void drainBridgeProcessStream(proc.stdout);
 
       const wsUrl =
         (await sandboxSession.getPortUrl({
@@ -672,6 +682,7 @@ export function createClaudeCode(
         connect: buildConnect(wsUrl),
         outboundSchema: outboundMessageSchema,
         onDiagnostic,
+        onBridgeError,
         // 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.
@@ -689,7 +700,7 @@ export function createClaudeCode(
         proc,
         model: settings.model,
         maxTurns: settings.maxTurns,
-        thinking: settings.thinking,
+        thinking,
         isResume: respawnStrategy !== undefined,
         continueOnFirstPrompt: respawnStrategy !== undefined,
         rerunContinue: respawnStrategy === 'rerun',
@@ -768,126 +779,6 @@ async function readBridgeAsset(name: string): Promise<string> {
   throw lastErr ?? new Error(`bridge asset not found: ${name}`);
 }
 
-async function createBridgeStartupError({
-  message,
-  proc,
-  stdoutTail,
-  stderrTail,
-  stderrDone,
-}: {
-  message: string;
-  proc: Experimental_SandboxProcess;
-  stdoutTail: string[];
-  stderrTail: string[];
-  stderrDone: Promise<void>;
-}): Promise<Error> {
-  await Promise.race([
-    stderrDone,
-    new Promise<void>(resolve => setTimeout(resolve, 250)),
-  ]).catch(() => {});
-
-  let exitStatus = '';
-  try {
-    const result = (await Promise.race([
-      proc.wait(),
-      new Promise<undefined>(resolve => setTimeout(resolve, 250)),
-    ])) as { exitCode?: number } | undefined;
-    if (result?.exitCode !== undefined) {
-      exitStatus = ` Exit code: ${result.exitCode}.`;
-    }
-  } catch {}
-
-  const details: string[] = [];
-  if (stdoutTail.length > 0) {
-    details.push(`stdout:\n${stdoutTail.join('\n')}`);
-  }
-  if (stderrTail.length > 0) {
-    details.push(`stderr:\n${stderrTail.join('\n')}`);
-  }
-
-  return new Error(
-    `${message}${exitStatus}${
-      details.length > 0 ? `\n\n${details.join('\n\n')}` : ''
-    }`,
-  );
-}
-
-function lineDecoder() {
-  let buffer = '';
-  return {
-    push(chunk: string): string[] {
-      buffer += chunk;
-      const lines: string[] = [];
-      let nl: number;
-      while ((nl = buffer.indexOf('\n')) !== -1) {
-        const raw = buffer.slice(0, nl);
-        buffer = buffer.slice(nl + 1);
-        const line = raw.replace(/\r$/, '').trim();
-        if (line.length > 0) lines.push(line);
-      }
-      return lines;
-    },
-    flush(): string[] {
-      const line = buffer.replace(/\r$/, '').trim();
-      buffer = '';
-      return line.length > 0 ? [line] : [];
-    },
-  };
-}
-
-async function forwardBridgeStderr({
-  stream,
-  collectTail,
-}: {
-  stream: ReadableStream<Uint8Array>;
-  collectTail?: string[];
-}): Promise<void> {
-  try {
-    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
-    const decoder = lineDecoder();
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) {
-        for (const line of decoder.flush()) {
-          const trimmed = line.trim();
-          if (!trimmed) continue;
-          if (collectTail) {
-            collectTail.push(trimmed);
-            if (collectTail.length > 20) collectTail.shift();
-          }
-          // eslint-disable-next-line no-console
-          console.log(`[bridge stderr] ${trimmed}`);
-        }
-        return;
-      }
-      if (value) {
-        for (const line of decoder.push(value)) {
-          const trimmed = line.trim();
-          if (!trimmed) continue;
-          if (collectTail) {
-            collectTail.push(trimmed);
-            if (collectTail.length > 20) collectTail.shift();
-          }
-          // eslint-disable-next-line no-console
-          console.log(`[bridge stderr] ${trimmed}`);
-        }
-      }
-    }
-  } catch {
-    // Reader errors are non-fatal — best-effort diagnostic only.
-  }
-}
-
-async function drainRest(stream: ReadableStream<Uint8Array>): Promise<void> {
-  try {
-    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
-    while (true) {
-      const { done } = await reader.read();
-      if (done) return;
-    }
-  } catch {}
-}
-
 /**
  * Wait for the bridge's `bridge-hello` message to arrive on the freshly
  * opened WebSocket before any other host-side code touches it.
@@ -1069,7 +960,7 @@ function createSession({
   proc: Experimental_SandboxProcess | undefined;
   model: string | undefined;
   maxTurns: number | undefined;
-  thinking: 'off' | 'on' | 'adaptive' | undefined;
+  thinking: ClaudeCodeThinkingConfig;
   isResume: boolean;
   continueOnFirstPrompt: boolean;
   rerunContinue: boolean;
@@ -1476,14 +1367,16 @@ function createSession({
       }
       stopped = true;
       /*
-       * Gracefully freeze the active turn at a precise cursor. `channel.suspend`
-       * stops processing inbound frames (the cursor stops advancing exactly at
-       * the last delivered event), drains what was already dispatched, then
-       * closes the host socket with reason `'suspended'` — which `wireTurn`'s
-       * `onClose` treats as a clean turn end. The bridge keeps the turn running
-       * and accumulates events past the cursor for the next slice to replay. The
+       * First ask the runtime to interrupt the active model turn, then freeze
+       * the host at a precise cursor. `channel.suspend` stops processing
+       * inbound frames (the cursor stops advancing exactly at the last
+       * delivered event), drains what was already dispatched, then closes the
+       * host socket with reason `'suspended'` — which `wireTurn`'s `onClose`
+       * treats as a clean turn end. The bridge keeps the turn running and
+       * accumulates events past the cursor for the next slice to replay. The
        * sandbox process is deliberately left alive (no `shutdown`/`detach`).
        */
+      await channel.interrupt();
       const lastSeenEventId = await channel.suspend();
       const payload: HarnessV1ContinueTurnState = {
         type: 'continue-turn',

package/src/claude-code-thinking.ts

@@ -0,0 +1,8 @@
+export type ClaudeCodeThinkingConfig =
+  | {
+      readonly type: 'adaptive' | 'enabled';
+      readonly display?: 'summarized' | 'omitted';
+    }
+  | {
+      readonly type: 'disabled';
+    };

package/src/index.ts

@@ -11,3 +11,4 @@ export { createClaudeCode } from './claude-code-harness';
 export { VERSION } from './version';
 export type { ClaudeCodeHarnessSettings } from './claude-code-harness';
 export type { ClaudeCodeAuthOptions } from './claude-code-auth';
+export type { ClaudeCodeThinkingConfig } from './claude-code-thinking';