opencode-gitlab-duo-agentic 0.2.9 → 0.2.11

package/dist/index.js

@@ -558,6 +558,14 @@ var TURN_COMPLETE_STATUSES = /* @__PURE__ */ new Set([
 function isTurnComplete(status) {
   return TURN_COMPLETE_STATUSES.has(status);
 }
+var AWAITING_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
+  WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED,
+  WORKFLOW_STATUS.INPUT_REQUIRED,
+  WORKFLOW_STATUS.PLAN_APPROVAL_REQUIRED
+]);
+function isAwaitingResponse(status) {
+  return AWAITING_RESPONSE_STATUSES.has(status);
+}
 
 // src/workflow/websocket-client.ts
 import WebSocket from "isomorphic-ws";
@@ -776,17 +784,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;
@@ -883,11 +880,7 @@ var WorkflowSession = class {
    * Send a tool result back to DWS on the existing connection.
    */
   sendToolResult(requestId, output, error) {
-    if (!this.#socket) {
-      dlog(`sendToolResult: NOT CONNECTED reqId=${requestId}`);
-      throw new Error("Not connected");
-    }
-    dlog(`sendToolResult: reqId=${requestId} output=${output.length}b err=${error ?? "none"}`);
+    if (!this.#socket) throw new Error("Not connected");
     this.#socket.send({
       actionResponse: {
         requestID: requestId,
@@ -903,10 +896,7 @@ var WorkflowSession = class {
    * Returns null when the stream is closed (turn complete or connection lost).
    */
   async waitForEvent() {
-    if (!this.#queue) {
-      dlog("waitForEvent: queue=null");
-      return null;
-    }
+    if (!this.#queue) return null;
     return this.#queue.shift();
   }
   /**
@@ -928,7 +918,6 @@ var WorkflowSession = class {
       }
       const toolRequests = extractToolRequests(ckpt, this.#checkpoint);
       for (const req of toolRequests) {
-        console.error(`[duo-workflow] checkpoint tool request: ${req.toolName} requestId=${req.requestId}`);
         queue.push({
           type: "tool-request",
           requestId: req.requestId,
@@ -936,7 +925,7 @@ var WorkflowSession = class {
           args: req.args
         });
       }
-      if (isTurnComplete(action.newCheckpoint.status)) {
+      if (isTurnComplete(action.newCheckpoint.status) && !isAwaitingResponse(action.newCheckpoint.status)) {
         queue.close();
         this.#closeConnection();
       }
@@ -945,7 +934,6 @@ var WorkflowSession = class {
     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,
@@ -1415,7 +1403,6 @@ var DuoWorkflowModel = class {
     const toolResults = extractToolResults(options.prompt);
     const session = this.#resolveSession(sessionID);
     const textId = randomUUID3();
-    dlog(`doStream: goal=${goal?.length ?? 0}chars, toolResults=${toolResults.length}, hasStarted=${session.hasStarted}`);
     if (sessionID !== this.#stateSessionId) {
       this.#pendingToolRequests.clear();
       this.#multiCallGroups.clear();
@@ -1442,6 +1429,7 @@ var DuoWorkflowModel = class {
               }
               model.#lastSentGoal = null;
             }
+            await session.ensureConnected(goal || "");
             const freshResults = toolResults.filter(
               (r) => !model.#sentToolCallIds.has(r.toolCallId)
             );
@@ -1469,11 +1457,9 @@ var DuoWorkflowModel = class {
               }
               const pending = model.#pendingToolRequests.get(result.toolCallId);
               if (!pending) {
-                dlog(`phase1: toolCallId=${result.toolCallId} pending=false SKIP`);
                 model.#sentToolCallIds.add(result.toolCallId);
                 continue;
               }
-              dlog(`phase1: toolCallId=${result.toolCallId} pending=true SEND output=${result.output.length}b`);
               session.sendToolResult(result.toolCallId, result.output, result.error);
               sentToolResults = true;
               model.#sentToolCallIds.add(result.toolCallId);
@@ -1524,10 +1510,7 @@ var DuoWorkflowModel = class {
             let hasText = false;
             while (true) {
               const event = await session.waitForEvent();
-              if (!event) {
-                dlog("phase3: event=null (queue closed)");
-                break;
-              }
+              if (!event) break;
               if (event.type === "text-delta") {
                 if (!event.value) continue;
                 if (!hasText) {
@@ -1541,10 +1524,7 @@ var DuoWorkflowModel = class {
                 let mapped;
                 try {
                   mapped = mapDuoToolRequest(event.toolName, event.args);
-                  const name = Array.isArray(mapped) ? mapped.map((m) => m.toolName).join(",") : mapped.toolName;
-                  dlog(`phase3: tool-request ${event.toolName} \u2192 ${name} reqId=${event.requestId}`);
                 } catch {
-                  dlog(`phase3: tool-request ${event.toolName} MAPPING FAILED`);
                   continue;
                 }
                 if (hasText) {
@@ -1561,20 +1541,28 @@ var DuoWorkflowModel = class {
                     model.#pendingToolRequests.set(subId, {});
                   }
                   for (let i = 0; i < mapped.length; i++) {
+                    const inputJson = JSON.stringify(mapped[i].args);
+                    controller.enqueue({ type: "tool-input-start", id: subIds[i], toolName: mapped[i].toolName });
+                    controller.enqueue({ type: "tool-input-delta", id: subIds[i], delta: inputJson });
+                    controller.enqueue({ type: "tool-input-end", id: subIds[i] });
                     controller.enqueue({
                       type: "tool-call",
                       toolCallId: subIds[i],
                       toolName: mapped[i].toolName,
-                      input: JSON.stringify(mapped[i].args)
+                      input: inputJson
                     });
                   }
                 } else {
                   model.#pendingToolRequests.set(event.requestId, {});
+                  const inputJson = JSON.stringify(mapped.args);
+                  controller.enqueue({ type: "tool-input-start", id: event.requestId, toolName: mapped.toolName });
+                  controller.enqueue({ type: "tool-input-delta", id: event.requestId, delta: inputJson });
+                  controller.enqueue({ type: "tool-input-end", id: event.requestId });
                   controller.enqueue({
                     type: "tool-call",
                     toolCallId: event.requestId,
                     toolName: mapped.toolName,
-                    input: JSON.stringify(mapped.args)
+                    input: inputJson
                   });
                 }
                 controller.enqueue({

package/package.json

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