opencode-gitlab-duo-agentic 0.2.12 → 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
@@ -784,17 +786,6 @@ function mapActionToToolRequest(action) {
   return null;
 }
 
-// src/utils/debug-log.ts
-import { appendFileSync } from "fs";
-var LOG = "/tmp/duo-workflow-debug.log";
-function dlog(msg) {
-  try {
-    appendFileSync(LOG, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
-`);
-  } catch {
-  }
-}
-
 // src/workflow/session.ts
 var WorkflowSession = class {
   #client;
@@ -809,6 +800,7 @@ var WorkflowSession = class {
   #socket;
   #queue;
   #startRequestSent = false;
+  #pendingApproval = false;
   constructor(client, modelId, cwd) {
     this.#client = client;
     this.#tokenService = new WorkflowTokenService(client);
@@ -832,6 +824,7 @@ var WorkflowSession = class {
     this.#checkpoint = createCheckpointState();
     this.#tokenService.clear();
     this.#closeConnection();
+    this.#pendingApproval = false;
     this.#startRequestSent = false;
   }
   // ---------------------------------------------------------------------------
@@ -842,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, {
@@ -891,7 +900,6 @@ var WorkflowSession = class {
    * Send a tool result back to DWS on the existing connection.
    */
   sendToolResult(requestId, output, error) {
-    dlog(`sendToolResult: reqId=${requestId} output=${output.length}b socket=${!!this.#socket}`);
     if (!this.#socket) throw new Error("Not connected");
     this.#socket.send({
       actionResponse: {
@@ -924,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({
@@ -937,20 +950,15 @@ var WorkflowSession = class {
           args: req.args
         });
       }
-      const status = action.newCheckpoint.status;
-      if (isTurnComplete(status) && !isAwaitingResponse(status)) {
-        dlog(`action: checkpoint status=${status} CLOSE`);
+      if (isTurnComplete(status)) {
         queue.close();
         this.#closeConnection();
-      } else {
-        dlog(`action: checkpoint status=${status} KEEP-ALIVE`);
       }
       return;
     }
     const toolAction = action;
     const mapped = mapActionToToolRequest(toolAction);
     if (mapped) {
-      dlog(`action: standalone ${mapped.toolName} reqId=${mapped.requestId}`);
       queue.push({
         type: "tool-request",
         requestId: mapped.requestId,
@@ -962,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;
@@ -1420,7 +1466,6 @@ var DuoWorkflowModel = class {
     const toolResults = extractToolResults(options.prompt);
     const session = this.#resolveSession(sessionID);
     const textId = randomUUID3();
-    dlog(`doStream: goal=${goal?.length ?? 0}ch toolResults=${toolResults.length} hasStarted=${session.hasStarted} pending=${this.#pendingToolRequests.size} sent=${this.#sentToolCallIds.size}`);
     if (sessionID !== this.#stateSessionId) {
       this.#pendingToolRequests.clear();
       this.#multiCallGroups.clear();
@@ -1451,10 +1496,6 @@ var DuoWorkflowModel = class {
             const freshResults = toolResults.filter(
               (r) => !model.#sentToolCallIds.has(r.toolCallId)
             );
-            dlog(`phase1: ${toolResults.length} total, ${freshResults.length} fresh, sentIds=${[...model.#sentToolCallIds].join(",")}`);
-            for (const r of toolResults) {
-              dlog(`  tr: id=${r.toolCallId} inSent=${model.#sentToolCallIds.has(r.toolCallId)} inPending=${model.#pendingToolRequests.has(r.toolCallId)} out=${r.output.length}b`);
-            }
             let sentToolResults = false;
             for (const result of freshResults) {
               const hashIdx = result.toolCallId.indexOf("#");
@@ -1479,11 +1520,9 @@ var DuoWorkflowModel = class {
               }
               const pending = model.#pendingToolRequests.get(result.toolCallId);
               if (!pending) {
-                dlog(`phase1: SKIP ${result.toolCallId} (not pending)`);
                 model.#sentToolCallIds.add(result.toolCallId);
                 continue;
               }
-              dlog(`phase1: SEND ${result.toolCallId} output=${result.output.length}b`);
               session.sendToolResult(result.toolCallId, result.output, result.error);
               sentToolResults = true;
               model.#sentToolCallIds.add(result.toolCallId);
@@ -1549,11 +1588,8 @@ var DuoWorkflowModel = class {
                 try {
                   mapped = mapDuoToolRequest(event.toolName, event.args);
                 } catch {
-                  dlog(`phase3: MAPPING FAILED ${event.toolName}`);
                   continue;
                 }
-                const mName = Array.isArray(mapped) ? mapped.map((m) => m.toolName).join(",") : mapped.toolName;
-                dlog(`phase3: tool-request ${event.toolName} \u2192 ${mName} reqId=${event.requestId}`);
                 if (hasText) {
                   controller.enqueue({ type: "text-end", id: textId });
                 }

package/package.json

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