opencode-gitlab-duo-agentic 0.2.11 → 0.2.14

package/dist/index.js

@@ -547,24 +547,26 @@ var WORKFLOW_STATUS = {
 function isCheckpointAction(action) {
   return "newCheckpoint" in action && action.newCheckpoint != null;
 }
-var TURN_COMPLETE_STATUSES = /* @__PURE__ */ new Set([
-  WORKFLOW_STATUS.INPUT_REQUIRED,
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   WORKFLOW_STATUS.FINISHED,
   WORKFLOW_STATUS.FAILED,
-  WORKFLOW_STATUS.STOPPED,
-  WORKFLOW_STATUS.PLAN_APPROVAL_REQUIRED,
-  WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED
+  WORKFLOW_STATUS.STOPPED
 ]);
-function isTurnComplete(status) {
-  return TURN_COMPLETE_STATUSES.has(status);
+function isTerminal(status) {
+  return TERMINAL_STATUSES.has(status);
 }
-var AWAITING_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
-  WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED,
+var TURN_BOUNDARY_STATUSES = /* @__PURE__ */ new Set([
   WORKFLOW_STATUS.INPUT_REQUIRED,
   WORKFLOW_STATUS.PLAN_APPROVAL_REQUIRED
 ]);
-function isAwaitingResponse(status) {
-  return AWAITING_RESPONSE_STATUSES.has(status);
+function isTurnBoundary(status) {
+  return TURN_BOUNDARY_STATUSES.has(status);
+}
+function isToolApproval(status) {
+  return status === WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED;
+}
+function isTurnComplete(status) {
+  return isTerminal(status) || isTurnBoundary(status);
 }
 
 // src/workflow/websocket-client.ts
@@ -798,6 +800,7 @@ var WorkflowSession = class {
   #socket;
   #queue;
   #startRequestSent = false;
+  #pendingApproval = false;
   constructor(client, modelId, cwd) {
     this.#client = client;
     this.#tokenService = new WorkflowTokenService(client);
@@ -821,6 +824,7 @@ var WorkflowSession = class {
     this.#checkpoint = createCheckpointState();
     this.#tokenService.clear();
     this.#closeConnection();
+    this.#pendingApproval = false;
     this.#startRequestSent = false;
   }
   // ---------------------------------------------------------------------------
@@ -831,13 +835,29 @@ var WorkflowSession = class {
     if (!this.#workflowId) {
       this.#workflowId = await this.#createWorkflow(goal);
     }
+    const queue = new AsyncQueue();
+    this.#queue = queue;
+    await this.#connectSocket(queue);
+  }
+  /**
+   * Open a WebSocket and wire its callbacks to the given queue.
+   * Replaces any existing socket but does NOT create a new queue.
+   */
+  async #connectSocket(queue) {
     await this.#tokenService.get(this.#rootNamespaceId);
-    this.#queue = new AsyncQueue();
-    const queue = this.#queue;
     const socket = new WorkflowWebSocketClient({
       action: (action) => this.#handleAction(action, queue),
       error: (error) => queue.push({ type: "error", message: error.message }),
-      close: (_code, _reason) => queue.close()
+      close: (_code, _reason) => {
+        this.#socket = void 0;
+        if (this.#pendingApproval) {
+          this.#pendingApproval = false;
+          this.#reconnectWithApproval(queue);
+        } else {
+          this.#queue = void 0;
+          queue.close();
+        }
+      }
     });
     const url = buildWebSocketUrl(this.#client.instanceUrl, this.#modelId);
     await socket.connect(url, {
@@ -912,10 +932,15 @@ var WorkflowSession = class {
   #handleAction(action, queue) {
     if (isCheckpointAction(action)) {
       const ckpt = action.newCheckpoint.checkpoint;
+      const status = action.newCheckpoint.status;
       const deltas = extractAgentTextDeltas(ckpt, this.#checkpoint);
       for (const delta of deltas) {
         queue.push({ type: "text-delta", value: delta });
       }
+      if (isToolApproval(status)) {
+        this.#pendingApproval = true;
+        return;
+      }
       const toolRequests = extractToolRequests(ckpt, this.#checkpoint);
       for (const req of toolRequests) {
         queue.push({
@@ -925,7 +950,7 @@ var WorkflowSession = class {
           args: req.args
         });
       }
-      if (isTurnComplete(action.newCheckpoint.status) && !isAwaitingResponse(action.newCheckpoint.status)) {
+      if (isTurnComplete(status)) {
         queue.close();
         this.#closeConnection();
       }
@@ -945,7 +970,45 @@ var WorkflowSession = class {
   // ---------------------------------------------------------------------------
   // Private: connection management
   // ---------------------------------------------------------------------------
+  /**
+   * Auto-approve at DWS protocol level and reconnect.
+   *
+   * DWS closed the stream after TOOL_CALL_APPROVAL_REQUIRED. We open a new
+   * WebSocket, send startRequest with approval, and wire it to the SAME queue
+   * so Phase 3 in the model continues consuming events seamlessly.
+   *
+   * The actual tool execution still goes through OpenCode's permission system
+   * when the standalone action arrives on the new stream.
+   */
+  #reconnectWithApproval(queue) {
+    this.#connectSocket(queue).then(() => {
+      if (!this.#socket || !this.#workflowId) {
+        queue.close();
+        return;
+      }
+      const mcpTools = this.#toolsConfig?.mcpTools ?? [];
+      this.#socket.send({
+        startRequest: {
+          workflowID: this.#workflowId,
+          clientVersion: WORKFLOW_CLIENT_VERSION,
+          workflowDefinition: WORKFLOW_DEFINITION,
+          goal: "",
+          workflowMetadata: JSON.stringify({ extended_logging: false }),
+          clientCapabilities: ["shell_command"],
+          mcpTools,
+          additional_context: [],
+          preapproved_tools: mcpTools.map((t) => t.name),
+          approval: { approval: {} }
+        }
+      });
+      this.#startRequestSent = true;
+    }).catch(() => {
+      this.#queue = void 0;
+      queue.close();
+    });
+  }
   #closeConnection() {
+    this.#pendingApproval = false;
     this.#socket?.close();
     this.#socket = void 0;
     this.#queue = void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gitlab-duo-agentic",
-  "version": "0.2.11",
+  "version": "0.2.14",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",