opencode-gitlab-duo-agentic 0.2.2 → 0.2.4

package/dist/index.js

@@ -391,10 +391,10 @@ function isGitLabProvider(model) {
 import { NoSuchModelError } from "@ai-sdk/provider";
 
 // src/provider/duo-workflow-model.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/workflow/session.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/utils/async-queue.ts
 var AsyncQueue = class {
@@ -416,9 +416,11 @@ var AsyncQueue = class {
 };
 
 // src/workflow/checkpoint.ts
+import { randomUUID } from "crypto";
 function createCheckpointState() {
   return {
-    uiChatLog: []
+    uiChatLog: [],
+    processedRequestIndices: /* @__PURE__ */ new Set()
   };
 }
 function extractAgentTextDeltas(checkpoint, state) {
@@ -443,6 +445,23 @@ 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 {
@@ -624,6 +643,16 @@ function decodeSocketMessage(data) {
 import { readFile, readdir, writeFile, mkdir as fsMkdir, stat } from "fs/promises";
 import { exec } from "child_process";
 import { resolve, dirname } from "path";
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => typeof v === "string");
+}
 var ToolExecutor = class {
   #cwd;
   #client;
@@ -631,9 +660,104 @@ var ToolExecutor = class {
     this.#cwd = cwd;
     this.#client = client;
   }
+  /**
+   * Execute a tool request using Duo tool names and arg formats.
+   * This handles checkpoint-based tool requests where tool_info contains
+   * Duo-native names (read_file, edit_file, etc.) and Duo-native arg keys
+   * (file_path, old_str, new_str, etc.).
+   */
+  async executeDuoTool(toolName, args) {
+    try {
+      switch (toolName) {
+        case "read_file": {
+          const filePath = asString(args.file_path) ?? asString(args.filepath) ?? asString(args.filePath) ?? asString(args.path);
+          if (!filePath) return { response: "", error: "read_file: missing file_path" };
+          return this.#read({ filePath, offset: asNumber(args.offset), limit: asNumber(args.limit) });
+        }
+        case "read_files": {
+          const paths = asStringArray(args.file_paths);
+          if (paths.length === 0) return { response: "", error: "read_files: missing file_paths" };
+          return this.#readMultiple(paths);
+        }
+        case "create_file_with_contents": {
+          const filePath = asString(args.file_path);
+          const content = asString(args.contents);
+          if (!filePath || content === void 0) return { response: "", error: "create_file: missing file_path or contents" };
+          return this.#write({ filePath, content });
+        }
+        case "edit_file": {
+          const filePath = asString(args.file_path);
+          const oldString = asString(args.old_str);
+          const newString = asString(args.new_str);
+          if (!filePath || oldString === void 0 || newString === void 0) {
+            return { response: "", error: "edit_file: missing file_path, old_str or new_str" };
+          }
+          return this.#edit({ filePath, oldString, newString });
+        }
+        case "list_dir": {
+          const directory = asString(args.directory) ?? ".";
+          return this.#read({ filePath: directory });
+        }
+        case "find_files": {
+          const pattern = asString(args.name_pattern);
+          if (!pattern) return { response: "", error: "find_files: missing name_pattern" };
+          return this.#glob({ pattern });
+        }
+        case "grep": {
+          const pattern = asString(args.pattern);
+          if (!pattern) return { response: "", error: "grep: missing pattern" };
+          return this.#grep({
+            pattern,
+            path: asString(args.search_directory),
+            caseInsensitive: Boolean(args.case_insensitive)
+          });
+        }
+        case "mkdir": {
+          const dir = asString(args.directory_path);
+          if (!dir) return { response: "", error: "mkdir: missing directory_path" };
+          return this.#mkdir(dir);
+        }
+        case "shell_command": {
+          const command = asString(args.command);
+          if (!command) return { response: "", error: "shell_command: missing command" };
+          return this.#bash({ command });
+        }
+        case "run_command": {
+          const program = asString(args.program);
+          if (!program) return { response: "", error: "run_command: missing program" };
+          const parts = [program];
+          const flags = args.flags;
+          if (Array.isArray(flags)) parts.push(...flags.map(String));
+          const cmdArgs = args.arguments;
+          if (Array.isArray(cmdArgs)) parts.push(...cmdArgs.map(String));
+          return this.#bash({ command: parts.join(" ") });
+        }
+        case "run_git_command": {
+          const command = asString(args.command);
+          if (!command) return { response: "", error: "run_git_command: missing command" };
+          const extra = Array.isArray(args.args) ? args.args.map(String).join(" ") : asString(args.args);
+          const gitCmd = extra ? `git ${command} ${extra}` : `git ${command}`;
+          return this.#bash({ command: gitCmd });
+        }
+        case "gitlab_api_request": {
+          const method = asString(args.method) ?? "GET";
+          const path3 = asString(args.path);
+          if (!path3) return { response: "", error: "gitlab_api_request: missing path" };
+          return this.#httpRequest({ method, path: path3, body: asString(args.body) });
+        }
+        default: {
+          console.error(`[tool-executor] unknown Duo tool: ${toolName}, args: ${JSON.stringify(args).slice(0, 300)}`);
+          return { response: "", error: `Unknown Duo tool: ${toolName}` };
+        }
+      }
+    } catch (err) {
+      console.error(`[tool-executor] executeDuoTool error:`, err);
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
   /**
    * Route a Duo WorkflowToolAction to the appropriate local handler.
-   * This is the main bridge entry point.
+   * This handles standalone WebSocket actions (non-checkpoint path).
    */
   async executeAction(action) {
     try {
@@ -695,8 +819,11 @@ var ToolExecutor = class {
       if (action.runHTTPRequest) {
         return this.#httpRequest(action.runHTTPRequest);
       }
-      return { response: "", error: "Unknown tool action" };
+      const keys = Object.keys(action).filter((k) => k !== "requestID");
+      console.error(`[tool-executor] unhandled action, keys: ${JSON.stringify(keys)}, raw: ${JSON.stringify(action).slice(0, 500)}`);
+      return { response: "", error: `Unknown tool action (keys: ${keys.join(", ")})` };
     } catch (err) {
+      console.error(`[tool-executor] execution error:`, err);
       return { response: "", error: err instanceof Error ? err.message : String(err) };
     }
   }
@@ -946,7 +1073,7 @@ var WorkflowSession = class {
       await socket.connect(url, {
         authorization: `Bearer ${this.#client.token}`,
         origin: new URL(this.#client.instanceUrl).origin,
-        "x-request-id": randomUUID(),
+        "x-request-id": randomUUID2(),
         "x-gitlab-client-type": "node-websocket"
       });
       abortSignal?.addEventListener("abort", onAbort, { once: true });
@@ -961,7 +1088,7 @@ var WorkflowSession = class {
           workflowMetadata: JSON.stringify({
             extended_logging: access?.workflow_metadata?.extended_logging ?? false
           }),
-          clientCapabilities: [],
+          clientCapabilities: ["shell_command"],
           mcpTools,
           additional_context: [],
           preapproved_tools: preapprovedTools,
@@ -981,20 +1108,42 @@ var WorkflowSession = class {
           throw new Error(`workflow websocket closed abnormally (${event.code}): ${event.reason}`);
         }
         if (isCheckpointAction(event.action)) {
-          const deltas = extractAgentTextDeltas(event.action.newCheckpoint.checkpoint, this.#checkpoint);
+          const ckpt = event.action.newCheckpoint.checkpoint;
+          const deltas = extractAgentTextDeltas(ckpt, this.#checkpoint);
           for (const delta of deltas) {
             yield {
               type: "text-delta",
               value: delta
             };
           }
+          const toolRequests = extractToolRequests(ckpt, this.#checkpoint);
+          for (const req of toolRequests) {
+            console.error(`[duo-workflow] checkpoint tool request: ${req.toolName} requestId=${req.requestId} args=${JSON.stringify(req.args).slice(0, 200)}`);
+            const result2 = await this.#toolExecutor.executeDuoTool(req.toolName, req.args);
+            console.error(`[duo-workflow] checkpoint tool result: ${result2.response.length} bytes, error=${result2.error ?? "none"}`);
+            socket.send({
+              actionResponse: {
+                requestID: req.requestId,
+                plainTextResponse: {
+                  response: result2.response,
+                  error: result2.error ?? ""
+                }
+              }
+            });
+          }
           if (isTurnComplete(event.action.newCheckpoint.status)) {
             socket.close();
           }
           continue;
         }
-        if (!event.action.requestID) continue;
+        const actionKeys = Object.keys(event.action).filter((k) => k !== "requestID");
+        console.error(`[duo-workflow] tool action received: keys=${JSON.stringify(actionKeys)} requestID=${event.action.requestID ?? "MISSING"}`);
+        if (!event.action.requestID) {
+          console.error("[duo-workflow] skipping action without requestID");
+          continue;
+        }
         const result = await this.#toolExecutor.executeAction(event.action);
+        console.error(`[duo-workflow] tool result: response=${result.response.length} bytes, error=${result.error ?? "none"}`);
         socket.send({
           actionResponse: {
             requestID: event.action.requestID,
@@ -1150,7 +1299,7 @@ var DuoWorkflowModel = class {
     const goal = extractGoal(options.prompt);
     if (!goal) throw new Error("missing user message content");
     const session = this.#resolveSession(sessionID);
-    const textId = randomUUID2();
+    const textId = randomUUID3();
     return {
       stream: new ReadableStream({
         start: async (controller) => {

package/package.json

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