gitlab-ai-provider 6.12.0 → 6.12.2

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 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))
+- perf(anthropic): place cache breakpoints on final two messages ([5f2e13e](https://gitlab.com/vglafirov/gitlab-ai-provider/commit/5f2e13e))
+
 ## 6.12.0 (2026-07-27)
 
 - Merge branch 'feature-add-opus-5' into 'main' ([9a5f447](https://gitlab.com/vglafirov/gitlab-ai-provider/commit/9a5f447))

package/dist/index.d.mts

@@ -88,11 +88,17 @@ declare class GitLabAnthropicLanguageModel implements LanguageModelV3 {
      *
      * Cache breakpoints (`cache_control: { type: "ephemeral" }`) are placed on:
      * 1. The system prompt content block — static across all turns.
-     * 2. The last content block of the second-to-last message — the boundary
-     *    between conversation history and the current turn.
+     * 2. The last content block of each of the final two messages.
      *
-     * This lets Anthropic cache the system prompt and the accumulated
-     * conversation prefix, so each new turn only pays for the new content.
+     * Two trailing breakpoints (rather than a single one on the penultimate
+     * message) keep a cache write within Anthropic's 20-block lookback window
+     * as an agentic conversation grows several messages per turn (assistant
+     * tool-call → tool-result → …). With a single breakpoint the most recent
+     * write can drift more than 20 blocks behind the current position, so the
+     * next request fails to prefix-match and pays for a fresh cache write
+     * instead of a cheap read. The extra breakpoint costs nothing (breakpoints
+     * themselves are free; you only pay for tokens actually written/read) and
+     * materially raises the cache hit rate in multi-turn tool-using sessions.
      *
      * @see https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
      */
@@ -888,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;
     /**
@@ -1560,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

@@ -88,11 +88,17 @@ declare class GitLabAnthropicLanguageModel implements LanguageModelV3 {
      *
      * Cache breakpoints (`cache_control: { type: "ephemeral" }`) are placed on:
      * 1. The system prompt content block — static across all turns.
-     * 2. The last content block of the second-to-last message — the boundary
-     *    between conversation history and the current turn.
+     * 2. The last content block of each of the final two messages.
      *
-     * This lets Anthropic cache the system prompt and the accumulated
-     * conversation prefix, so each new turn only pays for the new content.
+     * Two trailing breakpoints (rather than a single one on the penultimate
+     * message) keep a cache write within Anthropic's 20-block lookback window
+     * as an agentic conversation grows several messages per turn (assistant
+     * tool-call → tool-result → …). With a single breakpoint the most recent
+     * write can drift more than 20 blocks behind the current position, so the
+     * next request fails to prefix-match and pays for a fresh cache write
+     * instead of a cheap read. The extra breakpoint costs nothing (breakpoints
+     * themselves are free; you only pay for tokens actually written/read) and
+     * materially raises the cache hit rate in multi-turn tool-using sessions.
      *
      * @see https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
      */
@@ -888,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;
     /**
@@ -1560,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";
@@ -929,11 +933,17 @@ var GitLabAnthropicLanguageModel = class {
    *
    * Cache breakpoints (`cache_control: { type: "ephemeral" }`) are placed on:
    * 1. The system prompt content block — static across all turns.
-   * 2. The last content block of the second-to-last message — the boundary
-   *    between conversation history and the current turn.
+   * 2. The last content block of each of the final two messages.
    *
-   * This lets Anthropic cache the system prompt and the accumulated
-   * conversation prefix, so each new turn only pays for the new content.
+   * Two trailing breakpoints (rather than a single one on the penultimate
+   * message) keep a cache write within Anthropic's 20-block lookback window
+   * as an agentic conversation grows several messages per turn (assistant
+   * tool-call → tool-result → …). With a single breakpoint the most recent
+   * write can drift more than 20 blocks behind the current position, so the
+   * next request fails to prefix-match and pays for a fresh cache write
+   * instead of a cheap read. The extra breakpoint costs nothing (breakpoints
+   * themselves are free; you only pay for tokens actually written/read) and
+   * materially raises the cache hit rate in multi-turn tool-using sessions.
    *
    * @see https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
    */
@@ -1022,10 +1032,11 @@ ${message.content}` : message.content;
         cache_control: { type: "ephemeral" }
       }
     ] : void 0;
-    if (messages.length >= 2) {
-      const penultimate = messages[messages.length - 2];
-      if (Array.isArray(penultimate.content)) {
-        const lastBlock = penultimate.content[penultimate.content.length - 1];
+    const breakpointCount = Math.min(2, messages.length);
+    for (let i = messages.length - breakpointCount; i < messages.length; i++) {
+      const message = messages[i];
+      if (Array.isArray(message.content) && message.content.length > 0) {
+        const lastBlock = message.content[message.content.length - 1];
         lastBlock.cache_control = {
           type: "ephemeral"
         };
@@ -2519,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.11.1" : "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;
@@ -2669,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.
    */
@@ -4628,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,
@@ -4651,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