gitlab-ai-provider 6.12.1 → 6.12.2

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## <small>6.12.2 (2026-08-24)</small>
+
+- Merge branch 'fix/workflow-lock-reconnect-race' into 'main' ([51a9277](https://gitlab.com/vglafirov/gitlab-ai-provider/commit/51a9277))
+- fix(workflow): wait out the workflow lock before reconnecting after approval ([35ca694](https://gitlab.com/vglafirov/gitlab-ai-provider/commit/35ca694))
+
 ## <small>6.12.1 (2026-07-29)</small>
 
 - Merge branch 'ghavenga-cache-breakpoint-placement' into 'main' ([e8d0fe5](https://gitlab.com/vglafirov/gitlab-ai-provider/commit/e8d0fe5))

package/dist/index.d.mts

@@ -894,6 +894,15 @@ declare class GitLabWorkflowLanguageModel implements LanguageModelV3 {
     private executeToolAndRespond;
     private cleanupClient;
     private approveAndResume;
+    /**
+     * Close the active client and wait for its close handshake, so a following
+     * reconnect to the same workflow does not race the Workhorse lock.
+     */
+    private closeClientAndWait;
+    /**
+     * Surface a terminal error on the stream and drop the workflow.
+     */
+    private failStream;
     private buildWorkflowMetadata;
     private getGitInfo;
     /**
@@ -1566,6 +1575,22 @@ declare class GitLabWorkflowClient {
      * Close the WebSocket connection.
      */
     close(): void;
+    /**
+     * Close the socket and wait for the close handshake to actually land.
+     *
+     * `close()` returns as soon as the close frame is queued. That is too early
+     * when the caller is about to reconnect to the same workflow, because
+     * Workhorse releases the workflow lock only once its own stop handshake with
+     * DWS completes. Awaiting `onclose` (or the timeout) keeps the reconnect from
+     * racing the lock and getting rejected with close code 1013.
+     *
+     * Best effort: never rejects, and resolves after `timeoutMs` if the server
+     * never answers.
+     *
+     * @param timeoutMs - Maximum time to wait for the close event
+     * @default WS_CLOSE_WAIT_TIMEOUT_MS
+     */
+    closeAndWait(timeoutMs?: number): Promise<void>;
     /**
      * Check if the WebSocket is currently connected.
      */

package/dist/index.d.ts

@@ -894,6 +894,15 @@ declare class GitLabWorkflowLanguageModel implements LanguageModelV3 {
     private executeToolAndRespond;
     private cleanupClient;
     private approveAndResume;
+    /**
+     * Close the active client and wait for its close handshake, so a following
+     * reconnect to the same workflow does not race the Workhorse lock.
+     */
+    private closeClientAndWait;
+    /**
+     * Surface a terminal error on the stream and drop the workflow.
+     */
+    private failStream;
     private buildWorkflowMetadata;
     private getGitInfo;
     /**
@@ -1566,6 +1575,22 @@ declare class GitLabWorkflowClient {
      * Close the WebSocket connection.
      */
     close(): void;
+    /**
+     * Close the socket and wait for the close handshake to actually land.
+     *
+     * `close()` returns as soon as the close frame is queued. That is too early
+     * when the caller is about to reconnect to the same workflow, because
+     * Workhorse releases the workflow lock only once its own stop handshake with
+     * DWS completes. Awaiting `onclose` (or the timeout) keeps the reconnect from
+     * racing the lock and getting rejected with close code 1013.
+     *
+     * Best effort: never rejects, and resolves after `timeoutMs` if the server
+     * never answers.
+     *
+     * @param timeoutMs - Maximum time to wait for the close event
+     * @default WS_CLOSE_WAIT_TIMEOUT_MS
+     */
+    closeAndWait(timeoutMs?: number): Promise<void>;
     /**
      * Check if the WebSocket is currently connected.
      */

package/dist/index.js

@@ -482,6 +482,10 @@ var WorkflowType = /* @__PURE__ */ ((WorkflowType2) => {
 })(WorkflowType || {});
 var WS_KEEPALIVE_PING_INTERVAL_MS = 45e3;
 var WS_HEARTBEAT_INTERVAL_MS = 6e4;
+var WS_CLOSE_WORKFLOW_LOCKED = 1013;
+var WS_CLOSE_WAIT_TIMEOUT_MS = 3e3;
+var WS_WORKFLOW_LOCK_RETRY_DELAY_MS = 1500;
+var WS_WORKFLOW_LOCK_MAX_RETRIES = 8;
 var DEFAULT_WORKFLOW_DEFINITION = "chat" /* CHAT */;
 var DEFAULT_CLIENT_CAPABILITIES = ["shell_command"];
 var CLIENT_VERSION = "8.51.0";
@@ -2526,7 +2530,7 @@ var import_node_async_hooks = require("async_hooks");
 var import_isomorphic_ws = __toESM(require("isomorphic-ws"));
 
 // src/version.ts
-var VERSION = true ? "6.12.0" : "0.0.0-dev";
+var VERSION = true ? "6.12.1" : "0.0.0-dev";
 
 // src/gitlab-workflow-client.ts
 var WS_CONNECT_TIMEOUT_MS = 3e4;
@@ -2676,6 +2680,48 @@ var GitLabWorkflowClient = class {
       }
     }
   }
+  /**
+   * Close the socket and wait for the close handshake to actually land.
+   *
+   * `close()` returns as soon as the close frame is queued. That is too early
+   * when the caller is about to reconnect to the same workflow, because
+   * Workhorse releases the workflow lock only once its own stop handshake with
+   * DWS completes. Awaiting `onclose` (or the timeout) keeps the reconnect from
+   * racing the lock and getting rejected with close code 1013.
+   *
+   * Best effort: never rejects, and resolves after `timeoutMs` if the server
+   * never answers.
+   *
+   * @param timeoutMs - Maximum time to wait for the close event
+   * @default WS_CLOSE_WAIT_TIMEOUT_MS
+   */
+  closeAndWait(timeoutMs = WS_CLOSE_WAIT_TIMEOUT_MS) {
+    const sock = this.socket;
+    const pending = sock && (sock.readyState === import_isomorphic_ws.default.OPEN || sock.readyState === import_isomorphic_ws.default.CONNECTING);
+    if (this.closed || !pending) {
+      this.close();
+      return Promise.resolve();
+    }
+    return new Promise((resolve3) => {
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve3();
+      };
+      const timer = setTimeout(finish, timeoutMs);
+      const previous = sock.onclose;
+      sock.onclose = (event) => {
+        try {
+          previous?.call(sock, event);
+        } finally {
+          finish();
+        }
+      };
+      this.close();
+    });
+  }
   /**
    * Check if the WebSocket is currently connected.
    */
@@ -4635,19 +4681,20 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
     }
     ss.approvalPending = false;
     ss.deferredClose = null;
-    this.cleanupClient(ss, false);
     const approval = decision.approved ? { approval: { tool_name: tools[0]?.name, tool_args_json: tools[0]?.args } } : { rejection: { message: decision.message ?? "User rejected" } };
     const newStartReq = {
       ...startReq,
       approval,
       preapproved_tools: decision.approved ? [...startReq.preapproved_tools ?? [], ...tools.map((t) => t.name)] : startReq.preapproved_tools ?? []
     };
-    const newClient = new GitLabWorkflowClient();
-    this.activeClients.add(newClient);
-    ss.activeClient = newClient;
-    const modelRef = await this.resolveModelRef();
-    try {
-      await newClient.connect(
+    const reconnect = async () => {
+      if (ss.streamClosed) return;
+      await this.closeClientAndWait(ss);
+      const client = new GitLabWorkflowClient();
+      this.activeClients.add(client);
+      ss.activeClient = client;
+      const modelRef = await this.resolveModelRef();
+      await client.connect(
         {
           instanceUrl: this.config.instanceUrl,
           modelRef,
@@ -4658,23 +4705,63 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
           aiCatalogItemVersionId: wsExtras?.aiCatalogItemVersionId,
           workflowDefinition: wsExtras?.workflowDefinition
         },
-        (event) => this.handleWorkflowEvent(
+        (event) => {
+          if (event.type === "closed" && event.code === WS_CLOSE_WORKFLOW_LOCKED) {
+            void retryWhileLocked();
+            return;
+          }
+          this.handleWorkflowEvent(
+            ss,
+            event,
+            controller,
+            client,
+            toolExecutor,
+            nextTextId,
+            availableToolNames,
+            newStartReq,
+            wsExtras
+          );
+        }
+      );
+      client.sendStartRequest(newStartReq);
+    };
+    let lockRetries = 0;
+    const retryWhileLocked = async () => {
+      if (ss.streamClosed) return;
+      if (++lockRetries > WS_WORKFLOW_LOCK_MAX_RETRIES) {
+        this.failStream(
           ss,
-          event,
           controller,
-          newClient,
-          toolExecutor,
-          nextTextId,
-          availableToolNames,
-          newStartReq,
-          wsExtras
-        )
-      );
-      newClient.sendStartRequest(newStartReq);
-    } catch (err) {
-      this.cleanupClient(ss, true);
-      if (!ss.streamClosed) controller.error(err);
-    }
+          new GitLabError({
+            message: "Failed to acquire lock on workflow after reconnect retries",
+            statusCode: WS_CLOSE_WORKFLOW_LOCKED
+          })
+        );
+        return;
+      }
+      await new Promise((r) => setTimeout(r, WS_WORKFLOW_LOCK_RETRY_DELAY_MS * lockRetries));
+      await reconnect().catch((err) => this.failStream(ss, controller, err));
+    };
+    await reconnect().catch((err) => this.failStream(ss, controller, err));
+  }
+  /**
+   * Close the active client and wait for its close handshake, so a following
+   * reconnect to the same workflow does not race the Workhorse lock.
+   */
+  async closeClientAndWait(ss) {
+    const client = ss.activeClient;
+    if (!client) return;
+    this.activeClients.delete(client);
+    ss.activeClient = null;
+    await client.closeAndWait();
+  }
+  /**
+   * Surface a terminal error on the stream and drop the workflow.
+   */
+  failStream(ss, controller, error) {
+    this.cleanupClient(ss, true);
+    if (ss.streamClosed) return;
+    controller.error(error);
   }
   // ---------------------------------------------------------------------------
   // Workflow metadata