opencode-gitlab-duo-agentic 0.2.14 → 0.2.16

package/dist/index.js

@@ -456,23 +456,6 @@ function extractAgentTextDeltas(checkpoint, state) {
   state.uiChatLog = next;
   return out;
 }
-function extractToolRequests(checkpoint, state) {
-  const next = parseCheckpoint(checkpoint);
-  const requests = [];
-  for (let i = 0; i < next.length; i++) {
-    const item = next[i];
-    if (item.message_type !== "request") continue;
-    if (!item.tool_info) continue;
-    if (state.processedRequestIndices.has(i)) continue;
-    state.processedRequestIndices.add(i);
-    requests.push({
-      requestId: item.correlation_id ?? randomUUID(),
-      toolName: item.tool_info.name,
-      args: item.tool_info.args ?? {}
-    });
-  }
-  return requests;
-}
 function parseCheckpoint(raw) {
   if (!raw) return [];
   try {
@@ -786,6 +769,15 @@ function mapActionToToolRequest(action) {
   return null;
 }
 
+// src/utils/debug-log.ts
+import { appendFileSync } from "fs";
+var LOG_FILE = "/tmp/duo-workflow-debug.log";
+function dlog(msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  appendFileSync(LOG_FILE, `[${ts}] ${msg}
+`);
+}
+
 // src/workflow/session.ts
 var WorkflowSession = class {
   #client;
@@ -848,7 +840,8 @@ var WorkflowSession = class {
     const socket = new WorkflowWebSocketClient({
       action: (action) => this.#handleAction(action, queue),
       error: (error) => queue.push({ type: "error", message: error.message }),
-      close: (_code, _reason) => {
+      close: (code, reason) => {
+        dlog(`ws-close: code=${code} reason=${reason} pendingApproval=${this.#pendingApproval}`);
         this.#socket = void 0;
         if (this.#pendingApproval) {
           this.#pendingApproval = false;
@@ -900,6 +893,7 @@ 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 error=${error ?? "none"} socket=${!!this.#socket}`);
     if (!this.#socket) throw new Error("Not connected");
     this.#socket.send({
       actionResponse: {
@@ -933,24 +927,21 @@ var WorkflowSession = class {
     if (isCheckpointAction(action)) {
       const ckpt = action.newCheckpoint.checkpoint;
       const status = action.newCheckpoint.status;
+      dlog(`checkpoint: status=${status} ckptLen=${ckpt.length}`);
       const deltas = extractAgentTextDeltas(ckpt, this.#checkpoint);
       for (const delta of deltas) {
         queue.push({ type: "text-delta", value: delta });
       }
+      if (deltas.length > 0) {
+        dlog(`checkpoint: ${deltas.length} text deltas`);
+      }
       if (isToolApproval(status)) {
+        dlog(`checkpoint: TOOL_APPROVAL \u2192 pendingApproval=true (waiting for DWS close)`);
         this.#pendingApproval = true;
         return;
       }
-      const toolRequests = extractToolRequests(ckpt, this.#checkpoint);
-      for (const req of toolRequests) {
-        queue.push({
-          type: "tool-request",
-          requestId: req.requestId,
-          toolName: req.toolName,
-          args: req.args
-        });
-      }
       if (isTurnComplete(status)) {
+        dlog(`checkpoint: turnComplete \u2192 close queue+connection`);
         queue.close();
         this.#closeConnection();
       }
@@ -959,12 +950,15 @@ var WorkflowSession = class {
     const toolAction = action;
     const mapped = mapActionToToolRequest(toolAction);
     if (mapped) {
+      dlog(`standalone: ${mapped.toolName} reqId=${mapped.requestId} args=${JSON.stringify(mapped.args).slice(0, 200)}`);
       queue.push({
         type: "tool-request",
         requestId: mapped.requestId,
         toolName: mapped.toolName,
         args: mapped.args
       });
+    } else {
+      dlog(`standalone: UNMAPPED action keys=${Object.keys(action).join(",")}`);
     }
   }
   // ---------------------------------------------------------------------------
@@ -981,12 +975,15 @@ var WorkflowSession = class {
    * when the standalone action arrives on the new stream.
    */
   #reconnectWithApproval(queue) {
+    dlog(`reconnectWithApproval: starting (workflowId=${this.#workflowId})`);
     this.#connectSocket(queue).then(() => {
       if (!this.#socket || !this.#workflowId) {
+        dlog(`reconnectWithApproval: FAILED no socket/workflowId`);
         queue.close();
         return;
       }
       const mcpTools = this.#toolsConfig?.mcpTools ?? [];
+      dlog(`reconnectWithApproval: sending startRequest with approval (mcpTools=${mcpTools.length})`);
       this.#socket.send({
         startRequest: {
           workflowID: this.#workflowId,
@@ -1002,7 +999,9 @@ var WorkflowSession = class {
         }
       });
       this.#startRequestSent = true;
-    }).catch(() => {
+      dlog(`reconnectWithApproval: approval sent, waiting for standalone actions`);
+    }).catch((err) => {
+      dlog(`reconnectWithApproval: ERROR ${err instanceof Error ? err.message : String(err)}`);
       this.#queue = void 0;
       queue.close();
     });
@@ -1466,6 +1465,7 @@ 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();
@@ -1496,6 +1496,7 @@ var DuoWorkflowModel = class {
             const freshResults = toolResults.filter(
               (r) => !model.#sentToolCallIds.has(r.toolCallId)
             );
+            dlog(`phase1: ${toolResults.length} total, ${freshResults.length} fresh`);
             let sentToolResults = false;
             for (const result of freshResults) {
               const hashIdx = result.toolCallId.indexOf("#");
@@ -1520,9 +1521,11 @@ 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);
@@ -1588,8 +1591,11 @@ 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.14",
+  "version": "0.2.16",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",