@ai-sdk/harness-opencode 1.0.21 → 1.0.23

package/src/bridge/index.ts

@@ -21,6 +21,10 @@ import {
   type OpenCodeEvent,
   unwrapOpenCodeEvent,
 } from './opencode-events';
+import {
+  legacyStepFinishPartToFinishStep,
+  mapOpenCodeFinishReason,
+} from './opencode-finish-step';
 import { prependOpenCodeBinToPath } from './opencode-path';
 import {
   addUsage,
@@ -144,7 +148,7 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       totalUsage = await runPrompt({ client, sessionId, start, turn, emit });
     }
   } catch (err) {
-    emit({ type: 'error', error: serialiseError(err) });
+    turn.emitError({ error: err, message: 'OpenCode turn failed' });
   } finally {
     emit({
       type: 'finish',
@@ -469,11 +473,45 @@ function legacyStatusType(event: OpenCodeEvent): string | undefined {
     : undefined;
 }
 
-function legacyStatusMessage(event: OpenCodeEvent): string | undefined {
+function legacyRetryStatusMessage(event: OpenCodeEvent): string {
   const status = event.properties?.status;
-  if (!status || typeof status !== 'object') return undefined;
-  const message = (status as { message?: unknown }).message;
-  return typeof message === 'string' ? message : undefined;
+  const details: string[] = [];
+  if (status && typeof status === 'object') {
+    const retryStatus = status as { attempt?: unknown; message?: unknown };
+    if (typeof retryStatus.attempt === 'number') {
+      details.push(`attempt ${retryStatus.attempt}`);
+    }
+    if (typeof retryStatus.message === 'string' && retryStatus.message.trim()) {
+      details.push(retryStatus.message.trim());
+    }
+  }
+  return details.length > 0
+    ? `OpenCode session retry: ${details.join('; ')}`
+    : 'OpenCode session retry';
+}
+
+function nextRetryEventMessage(event: OpenCodeEvent): string {
+  const props = event.properties ?? {};
+  const details: string[] = [];
+  if (typeof props.attempt === 'number') {
+    details.push(`attempt ${props.attempt}`);
+  }
+  const error = props.error;
+  if (isRecord(error)) {
+    const message =
+      stringValue(error.message) ??
+      (isRecord(error.data) ? stringValue(error.data.message) : undefined);
+    const statusCode = error.statusCode;
+    if (typeof statusCode === 'number') {
+      details.push(`HTTP ${statusCode}`);
+    }
+    if (message) details.push(message);
+  } else if (error != null) {
+    details.push(formatError(error));
+  }
+  return details.length > 0
+    ? `OpenCode session retry: ${details.join('; ')}`
+    : 'OpenCode session retry';
 }
 
 async function ensureSession({
@@ -569,9 +607,7 @@ async function runPrompt({
         sawBusy = true;
       } else if (status === 'retry') {
         sawBusy = true;
-        terminalError = legacyStatusMessage(event) ?? 'Session retry';
-        turnSettled.resolve();
-        return true;
+        turn.emitWarning({ message: legacyRetryStatusMessage(event) });
       } else if (sawBusy && status === 'idle') {
         turnSettled.resolve();
         return true;
@@ -682,9 +718,7 @@ async function runCompaction({
         sawBusy = true;
       } else if (status === 'retry') {
         sawBusy = true;
-        terminalError = legacyStatusMessage(event) ?? 'Session retry';
-        compactionSettled.resolve();
-        return true;
+        turn.emitWarning({ message: legacyRetryStatusMessage(event) });
       } else if (sawBusy && status === 'idle') {
         compactionSettled.resolve();
         return true;
@@ -777,6 +811,7 @@ type TranslationState = {
   turnUsage: Record<string, unknown> | undefined;
   legacyTextPartIds: Set<string>;
   legacyReasoningPartIds: Set<string>;
+  legacyStepFinishPartIds: Set<string>;
 };
 
 function createTranslationState(): TranslationState {
@@ -793,6 +828,7 @@ function createTranslationState(): TranslationState {
     turnUsage: undefined,
     legacyTextPartIds: new Set(),
     legacyReasoningPartIds: new Set(),
+    legacyStepFinishPartIds: new Set(),
   };
 }
 
@@ -860,6 +896,7 @@ async function translateAndEmit({
 
   if (type === 'message.part.updated') {
     if (emitLegacyTextPartUpdate({ part: props.part, state, emit })) return;
+    if (emitLegacyStepFinishPart({ part: props.part, state, emit })) return;
     emitLegacyToolPart({ part: props.part, state, emit });
     return;
   }
@@ -1020,13 +1057,25 @@ async function translateAndEmit({
     });
     return;
   }
+  if (type === 'session.next.retried') {
+    const error = props.error ?? event;
+    if (isRecord(error) && error.isRetryable === false) {
+      turn.emitError({
+        error,
+        message: 'OpenCode session retry failed',
+      });
+    } else {
+      turn.emitWarning({ message: nextRetryEventMessage(event) });
+    }
+    return;
+  }
   if (type === 'session.next.step.ended') {
     closeLegacyOpenParts({ state, emit });
     state.turnUsage = mapUsage(props.tokens);
     emit({
       type: 'finish-step',
       finishReason: {
-        unified: mapFinishReason(String(props.finish ?? 'stop')),
+        unified: mapOpenCodeFinishReason(String(props.finish ?? 'stop')),
         raw: String(props.finish ?? 'stop'),
       },
       usage: state.turnUsage,
@@ -1058,7 +1107,14 @@ async function translateAndEmit({
     return;
   }
   if (type === 'session.error' || type === 'session.next.step.failed') {
-    emit({ type: 'error', error: formatError(props.error ?? event) });
+    const error = props.error ?? event;
+    turn.emitError({
+      error,
+      message:
+        type === 'session.error'
+          ? 'OpenCode session error'
+          : 'OpenCode step failed',
+    });
     return;
   }
   if (type === 'permission.v2.asked') {
@@ -1187,6 +1243,28 @@ function closeLegacyOpenParts({
   state.legacyTextPartIds.clear();
 }
 
+function emitLegacyStepFinishPart({
+  part,
+  state,
+  emit,
+}: {
+  part: unknown;
+  state: TranslationState;
+  emit: Emit;
+}): boolean {
+  const event = legacyStepFinishPartToFinishStep(part);
+  if (!event) return false;
+  const id = isRecord(part) ? stringValue(part.id) : undefined;
+  if (id) {
+    if (state.legacyStepFinishPartIds.has(id)) return true;
+    state.legacyStepFinishPartIds.add(id);
+  }
+  closeLegacyOpenParts({ state, emit });
+  state.turnUsage = event.usage as Record<string, unknown>;
+  emit(event);
+  return true;
+}
+
 function emitLegacyToolPart({
   part,
   state,
@@ -1592,7 +1670,7 @@ async function emitContextFallback({
   emit({
     type: 'finish-step',
     finishReason: {
-      unified: mapFinishReason(rawFinish),
+      unified: mapOpenCodeFinishReason(rawFinish),
       raw: rawFinish,
     },
     usage: mapUsage(assistant.tokens),
@@ -1724,19 +1802,6 @@ function emitAssistantContentPart(part: unknown, emit: Emit): void {
   emit({ type: 'reasoning-end', id });
 }
 
-function mapFinishReason(
-  reason: string,
-): 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' {
-  const normalized = reason.toLowerCase();
-  if (normalized.includes('length')) return 'length';
-  if (normalized.includes('filter')) return 'content-filter';
-  if (normalized.includes('tool')) return 'tool-calls';
-  if (normalized.includes('error') || normalized.includes('fail'))
-    return 'error';
-  if (normalized === 'stop' || normalized === 'end') return 'stop';
-  return 'other';
-}
-
 async function startToolRelay({
   allowedScriptPaths,
   tools,
@@ -1980,14 +2045,7 @@ function formatError(error: unknown): string {
   }
 }
 
-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 {
-  process.stderr.write(`[opencode bridge] ${message}\n`);
+  process.stderr.write(`[OpenCode bridge] ${message}\n`);
   process.exit(1);
 }

package/src/bridge/opencode-finish-step.ts

@@ -0,0 +1,39 @@
+import type { HarnessV1StreamPart } from '@ai-sdk/harness';
+import { mapUsage } from './opencode-usage';
+
+type FinishStepEvent = Extract<HarnessV1StreamPart, { type: 'finish-step' }>;
+
+export function mapOpenCodeFinishReason(
+  reason: string,
+): 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' {
+  const normalized = reason.toLowerCase();
+  if (normalized.includes('length')) return 'length';
+  if (normalized.includes('filter')) return 'content-filter';
+  if (normalized.includes('tool')) return 'tool-calls';
+  if (normalized.includes('error') || normalized.includes('fail'))
+    return 'error';
+  if (normalized === 'stop' || normalized === 'end') return 'stop';
+  return 'other';
+}
+
+export function legacyStepFinishPartToFinishStep(
+  part: unknown,
+): FinishStepEvent | undefined {
+  if (!isRecord(part) || part.type !== 'step-finish') return undefined;
+  const rawFinish = typeof part.reason === 'string' ? part.reason : 'stop';
+  return {
+    type: 'finish-step',
+    finishReason: {
+      unified: mapOpenCodeFinishReason(rawFinish),
+      raw: rawFinish,
+    },
+    usage: mapUsage(part.tokens),
+    ...(typeof part.cost === 'number'
+      ? { harnessMetadata: { opencode: { cost: part.cost } } }
+      : {}),
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/src/bridge/opencode-usage.ts

@@ -1,3 +1,7 @@
+import type { HarnessV1StreamPart } from '@ai-sdk/harness';
+
+type FinishStepEvent = Extract<HarnessV1StreamPart, { type: 'finish-step' }>;
+
 export type OpenCodeTokenUsage = {
   readonly input: number;
   readonly output: number;
@@ -8,7 +12,7 @@ export type OpenCodeTokenUsage = {
   };
 };
 
-export type HarnessUsage = Record<string, unknown>;
+export type HarnessUsage = FinishStepEvent['usage'];
 
 export function mapUsage(tokens: unknown): HarnessUsage {
   const value = extractOpenCodeTokens(tokens) ?? zeroOpenCodeTokens();

package/src/opencode-harness.ts

@@ -23,6 +23,10 @@ import {
 } from '@ai-sdk/harness';
 import {
   classifyDiskLog,
+  createBridgeErrorHandler,
+  createBridgeStartupError,
+  drainBridgeProcessStream,
+  forwardBridgeProcessStream,
   markBridgeStarting,
   resolveSandboxHomeDir,
   SandboxChannel,
@@ -274,6 +278,10 @@ export function createOpenCode(
               }),
             )
         : undefined;
+      const onBridgeError = createBridgeErrorHandler({
+        harnessId: 'opencode',
+        sessionId: startOpts.sessionId,
+      });
 
       if (coords) {
         try {
@@ -287,6 +295,7 @@ export function createOpenCode(
             outboundSchema: outboundMessageSchema,
             initialLastSeenEventId: coords.lastSeenEventId,
             onDiagnostic,
+            onBridgeError,
           });
           await attachChannel.open(isContinue ? { resume: true } : undefined);
           return createSession({
@@ -383,6 +392,13 @@ export function createOpenCode(
         env,
         abortSignal: startOpts.abortSignal,
       });
+      const stderrTail: string[] = [];
+      const bridgeStderrDone = forwardBridgeProcessStream({
+        stream: proc.stderr,
+        streamName: 'stderr',
+        source: 'opencode',
+        collectTail: stderrTail,
+      });
 
       const { port: boundPort } = await waitForBridgeReady({
         proc,
@@ -391,13 +407,24 @@ export function createOpenCode(
         bridgeType: 'opencode',
         timeoutMs,
         abortSignal: startOpts.abortSignal,
-        createTimeoutError: () =>
-          new Error('opencode bridge did not become ready in time.'),
-        createExitError: () =>
-          new Error('opencode bridge exited before becoming ready.'),
+        createTimeoutError: ({ proc, stdoutTail }) =>
+          createBridgeStartupError({
+            message: 'OpenCode bridge did not become ready in time.',
+            proc,
+            stdoutTail,
+            stderrTail,
+            stderrDone: bridgeStderrDone,
+          }),
+        createExitError: ({ proc, stdoutTail }) =>
+          createBridgeStartupError({
+            message: 'OpenCode bridge exited before becoming ready.',
+            proc,
+            stdoutTail,
+            stderrTail,
+            stderrDone: bridgeStderrDone,
+          }),
       });
-      void drainRest(proc.stdout);
-      void forwardBridgeStderr(proc.stderr);
+      void drainBridgeProcessStream(proc.stdout);
 
       const wsUrl =
         (await sandboxSession.getPortUrl({
@@ -409,6 +436,7 @@ export function createOpenCode(
         connect: () => openWebSocket(wsUrl),
         outboundSchema: outboundMessageSchema,
         onDiagnostic,
+        onBridgeError,
         ...(respawnStrategy === 'replay'
           ? { initialLastSeenEventId: coords?.lastSeenEventId ?? 0 }
           : {}),
@@ -448,7 +476,7 @@ function resolveBridgePort(
   throw new HarnessCapabilityUnsupportedError({
     harnessId: 'opencode',
     message:
-      'The opencode harness needs a TCP port exposed by the sandbox. ' +
+      'The OpenCode harness needs a TCP port exposed by the sandbox. ' +
       'Create the sandbox with `ports: [<port>]` or pass `createOpenCode({ port })`.',
   });
 }
@@ -497,34 +525,6 @@ async function writeOpenCodeSkills({
   return { skillsDir };
 }
 
-async function forwardBridgeStderr(
-  stream: ReadableStream<Uint8Array>,
-): Promise<void> {
-  try {
-    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) return;
-      if (value) {
-        const trimmed = value.endsWith('\n') ? value.slice(0, -1) : value;
-        if (trimmed.length > 0) {
-          console.log(`[bridge stderr] ${trimmed}`);
-        }
-      }
-    }
-  } catch {}
-}
-
-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 {}
-}
-
 function openWebSocket(url: string): Promise<WebSocket> {
   return new Promise((resolve, reject) => {
     const ws = new WebSocket(url);
@@ -668,7 +668,7 @@ function createSession({
         return;
       }
       settleError(
-        new Error('opencode bridge closed before the turn finished.'),
+        new Error('OpenCode bridge closed before the turn finished.'),
       );
     };
     channel.onClose(onClose);
@@ -811,7 +811,7 @@ function createSession({
     doDetach: async () => {
       if (stopped) {
         throw new Error(
-          `opencode session ${sessionId} is already stopped; cannot detach.`,
+          `OpenCode session ${sessionId} is already stopped; cannot detach.`,
         );
       }
       stopped = true;
@@ -867,7 +867,7 @@ function createSession({
     doStop: async () => {
       if (stopped) {
         throw new Error(
-          `opencode session ${sessionId} is already stopped; cannot stop.`,
+          `OpenCode session ${sessionId} is already stopped; cannot stop.`,
         );
       }
       stopped = true;
@@ -879,7 +879,7 @@ function createSession({
               unsub();
               reject(
                 new Error(
-                  `opencode session ${sessionId} did not reply to detach within 5s.`,
+                  `OpenCode session ${sessionId} did not reply to detach within 5s.`,
                 ),
               );
             }, 5000);
@@ -928,10 +928,11 @@ function createSession({
     doSuspendTurn: async () => {
       if (stopped) {
         throw new Error(
-          `opencode session ${sessionId} is stopped; cannot suspend.`,
+          `OpenCode session ${sessionId} is stopped; cannot suspend.`,
         );
       }
       stopped = true;
+      await channel.interrupt();
       const lastSeenEventId = await channel.suspend();
       const payload: HarnessV1ContinueTurnState = {
         type: 'continue-turn',
@@ -1011,7 +1012,7 @@ function extractUserText(prompt: HarnessV1Prompt): string {
     if (part.type !== 'text') {
       throw new HarnessCapabilityUnsupportedError({
         harnessId: 'opencode',
-        message: `The opencode harness does not yet support user message parts of type '${part.type}'. Pass a string or a user message whose content contains only text parts.`,
+        message: `The OpenCode harness does not yet support user message parts of type '${part.type}'. Pass a string or a user message whose content contains only text parts.`,
       });
     }
     parts.push(part.text);