@ai-sdk/harness-opencode 1.0.136 → 1.0.139

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-opencode",
-  "version": "1.0.136",
+  "version": "1.0.139",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,9 +26,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.134",
-    "@ai-sdk/provider": "4.0.20",
-    "@ai-sdk/provider-utils": "5.0.52",
+    "@ai-sdk/harness": "1.0.137",
+    "@ai-sdk/provider": "4.0.21",
+    "@ai-sdk/provider-utils": "5.0.53",
     "ws": "8.21.0"
   },
   "peerDependencies": {

package/src/bridge/index.ts

@@ -532,6 +532,16 @@ async function legacySessionPrompt({
   });
 }
 
+async function legacySessionAbort({
+  client,
+  sessionId,
+}: {
+  client: OpenCodeClient;
+  sessionId: string;
+}): Promise<{ error?: unknown; data?: unknown }> {
+  return (client as any).session.abort({ sessionID: sessionId });
+}
+
 async function legacySessionSummarize({
   client,
   sessionId,
@@ -656,7 +666,26 @@ async function runPrompt({
   emit: Emit;
 }): Promise<HarnessUsage | undefined> {
   const eventsAbort = new AbortController();
-  const turnSettled = createDeferred<'event' | 'stream-ended'>();
+  const turnSettled = createDeferred<'aborted' | 'event' | 'stream-ended'>();
+  const promptRequestSettled = createDeferred<void>();
+  let abortSessionPromise: Promise<void> | undefined;
+  const abortSession = () => {
+    eventsAbort.abort();
+    turn.experimental_userMessages.close();
+    turnSettled.resolve('aborted');
+    abortSessionPromise ??= (async () => {
+      await promptRequestSettled.promise;
+      const aborted = await legacySessionAbort({ client, sessionId });
+      if (aborted.error) {
+        throw new Error(
+          `OpenCode session abort failed: ${formatError(aborted.error)}`,
+        );
+      }
+    })();
+    void abortSessionPromise.catch(() => {});
+  };
+  turn.abortSignal.addEventListener('abort', abortSession, { once: true });
+  if (turn.abortSignal.aborted) abortSession();
   let sawContent = false;
   let sawFinishStep = false;
   let sawBusy = false;
@@ -800,22 +829,47 @@ async function runPrompt({
       }
     }
   })();
-  const prompted = await legacySessionPrompt({
-    client,
-    sessionId,
-    start,
-  });
-  if (prompted.error) {
-    eventsAbort.abort();
-    turn.experimental_userMessages.close(
-      new Error(`OpenCode prompt failed: ${formatError(prompted.error)}`),
-    );
-    throw new Error(`OpenCode prompt failed: ${formatError(prompted.error)}`);
+  if (!turn.abortSignal.aborted) {
+    let prompted: { error?: unknown; data?: unknown };
+    try {
+      prompted = await legacySessionPrompt({
+        client,
+        sessionId,
+        start,
+      });
+    } catch (error) {
+      promptRequestSettled.resolve(undefined);
+      turn.abortSignal.removeEventListener('abort', abortSession);
+      eventsAbort.abort();
+      turn.experimental_userMessages.close(error);
+      throw error;
+    }
+    promptRequestSettled.resolve(undefined);
+    if (prompted.error) {
+      turn.abortSignal.removeEventListener('abort', abortSession);
+      eventsAbort.abort();
+      turn.experimental_userMessages.close(
+        new Error(`OpenCode prompt failed: ${formatError(prompted.error)}`),
+      );
+      throw new Error(`OpenCode prompt failed: ${formatError(prompted.error)}`);
+    }
+  } else {
+    promptRequestSettled.resolve(undefined);
   }
   const settlement = await turnSettled.promise;
+  turn.abortSignal.removeEventListener('abort', abortSession);
   eventsAbort.abort();
   await eventLoop.catch(() => {});
   await userMessageLoop.catch(() => {});
+  if (settlement === 'aborted') {
+    try {
+      await abortSessionPromise;
+    } catch (error) {
+      closeRuntime();
+      throw error;
+    }
+    return undefined;
+  }
   if (settlement === 'stream-ended') {
     throw new Error('OpenCode event stream ended before the turn settled.');
   }

package/src/opencode-harness.ts

@@ -930,6 +930,7 @@ function createSession({
     : undefined;
   let selectedModel: string | undefined;
   let activeTurn = false;
+  let pendingTurnDrain: Promise<void> = Promise.resolve();
   const pendingCompactionParts: HarnessV1StreamPart[] = [];
 
   channel.on('bridge-thread', msg => {
@@ -940,6 +941,11 @@ function createSession({
     abortSignal?: AbortSignal;
   }): HarnessV1PromptControl => {
     activeTurn = true;
+    let resolveTurnDrain!: () => void;
+    const turnDrain = new Promise<void>(resolve => {
+      resolveTurnDrain = resolve;
+    });
+    pendingTurnDrain = turnDrain;
     let pendingResolve: (() => void) | undefined;
     let pendingReject: ((err: unknown) => void) | undefined;
     const done = new Promise<void>((resolve, reject) => {
@@ -955,7 +961,11 @@ function createSession({
       : undefined;
 
     const unsubs: Array<() => void> = [];
+    let isSettled = false;
+    let isFinished = false;
+    let drainingAfterAbort = false;
     const forward = (event: HarnessV1StreamPart) => {
+      if (isSettled) return;
       try {
         turnOpts.emit(event);
       } catch {}
@@ -977,22 +987,29 @@ function createSession({
       'compaction',
       'raw',
     ] as const;
-    let isSettled = false;
+    const finishTurn = () => {
+      if (isFinished) return;
+      isFinished = true;
+      activeTurn = false;
+      if (turnOpts.abortSignal) {
+        turnOpts.abortSignal.removeEventListener('abort', onAbort);
+      }
+      for (const u of unsubs) u();
+      resolveTurnDrain();
+    };
     const settleSuccess = () => {
       if (isSettled) return;
       isSettled = true;
-      activeTurn = false;
       userMessageSubmitter?.close();
-      for (const u of unsubs) u();
       pendingResolve!();
+      finishTurn();
     };
     const settleError = (err: unknown) => {
       if (isSettled) return;
       isSettled = true;
-      activeTurn = false;
       userMessageSubmitter?.close(err);
-      for (const u of unsubs) u();
       pendingReject!(err);
+      finishTurn();
     };
 
     for (const type of eventTypes) {
@@ -1004,18 +1021,30 @@ function createSession({
     }
     unsubs.push(
       channel.on('finish', msg => {
+        if (drainingAfterAbort) {
+          finishTurn();
+          return;
+        }
         forward(msg);
         settleSuccess();
       }),
     );
     unsubs.push(
       channel.on('error', msg => {
+        if (drainingAfterAbort) {
+          // The bridge emits finish from its finally block after an error.
+          return;
+        }
         forward(msg);
         settleError(msg.error);
       }),
     );
 
     const onClose = (_code?: number, reason?: string) => {
+      if (drainingAfterAbort) {
+        finishTurn();
+        return;
+      }
       if (isSettled) return;
       if (reason === 'suspended') {
         settleSuccess();
@@ -1032,10 +1061,13 @@ function createSession({
       try {
         channel.send({ type: 'abort' });
       } catch {}
-      settleError(
+      const error =
         turnOpts.abortSignal?.reason ??
-          new DOMException('Aborted', 'AbortError'),
-      );
+        new DOMException('Aborted', 'AbortError');
+      isSettled = true;
+      drainingAfterAbort = true;
+      userMessageSubmitter?.close(error);
+      pendingReject!(error);
     };
     if (turnOpts.abortSignal) {
       if (turnOpts.abortSignal.aborted) {
@@ -1108,6 +1140,7 @@ function createSession({
     control: HarnessV1PromptControl;
     skillWriteResult: WriteSkillsResult;
   }> => {
+    await pendingTurnDrain;
     if (
       opts.responseFormat?.type === 'json' &&
       opts.responseFormat.schema == null