gitlab-ai-provider 6.12.1 → 6.13.0

package/dist/index.mjs

@@ -403,6 +403,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";
@@ -1385,6 +1389,7 @@ import OpenAI from "openai";
 // src/model-mappings.ts
 var MODEL_MAPPINGS = {
   // Anthropic models
+  "duo-chat-fable-5-1": { provider: "anthropic", model: "claude-fable-5-1" },
   "duo-chat-fable-5": { provider: "anthropic", model: "claude-fable-5" },
   "duo-chat-opus-5": { provider: "anthropic", model: "claude-opus-5" },
   "duo-chat-opus-4-8": { provider: "anthropic", model: "claude-opus-4-8" },
@@ -2447,7 +2452,7 @@ import { AsyncResource } from "async_hooks";
 import WebSocket from "isomorphic-ws";
 
 // src/version.ts
-var VERSION = true ? "6.12.0" : "0.0.0-dev";
+var VERSION = true ? "6.12.2" : "0.0.0-dev";
 
 // src/gitlab-workflow-client.ts
 var WS_CONNECT_TIMEOUT_MS = 3e4;
@@ -2597,6 +2602,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 === WebSocket.OPEN || sock.readyState === WebSocket.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.
    */
@@ -4556,19 +4603,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,
@@ -4579,23 +4627,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