opencode-gitlab-duo-agentic 0.2.6 → 0.2.8

package/dist/index.js

@@ -135,8 +135,8 @@ async function resolveRootNamespaceId(client, namespaceId) {
 }
 async function readGitConfig(cwd) {
   const gitPath = path.join(cwd, ".git");
-  const stat2 = await fs.stat(gitPath);
-  if (stat2.isDirectory()) {
+  const stat = await fs.stat(gitPath);
+  if (stat.isDirectory()) {
     return fs.readFile(path.join(gitPath, "config"), "utf8");
   }
   const content = await fs.readFile(gitPath, "utf8");
@@ -415,7 +415,7 @@ var AsyncQueue = class {
     const value = this.#values.shift();
     if (value !== void 0) return Promise.resolve(value);
     if (this.#closed) return Promise.resolve(null);
-    return new Promise((resolve2) => this.#waiters.push(resolve2));
+    return new Promise((resolve) => this.#waiters.push(resolve));
   }
   close() {
     this.#closed = true;
@@ -572,7 +572,7 @@ var WorkflowWebSocketClient = class {
   async connect(url, headers) {
     const socket = new WebSocket(url, { headers });
     this.#socket = socket;
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         cleanup();
         socket.close(1e3);
@@ -585,7 +585,7 @@ var WorkflowWebSocketClient = class {
       };
       const onOpen = () => {
         cleanup();
-        resolve2();
+        resolve();
       };
       const onError = (error) => {
         cleanup();
@@ -650,375 +650,142 @@ function decodeSocketMessage(data) {
   return void 0;
 }
 
-// src/workflow/tool-executor.ts
-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;
-  constructor(cwd, client) {
-    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}` };
-        }
+// src/workflow/action-mapper.ts
+function mapActionToToolRequest(action) {
+  const requestId = action.requestID;
+  if (!requestId) return null;
+  if (action.runMCPTool) {
+    let parsedArgs;
+    if (typeof action.runMCPTool.args === "string") {
+      try {
+        parsedArgs = JSON.parse(action.runMCPTool.args);
+      } catch {
+        parsedArgs = {};
       }
-    } catch (err) {
-      console.error(`[tool-executor] executeDuoTool error:`, err);
-      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    } else {
+      parsedArgs = {};
     }
+    return { requestId, toolName: action.runMCPTool.name, args: parsedArgs };
   }
-  /**
-   * Route a Duo WorkflowToolAction to the appropriate local handler.
-   * This handles standalone WebSocket actions (non-checkpoint path).
-   */
-  async executeAction(action) {
-    try {
-      if (action.runReadFile) {
-        return this.#read({
-          filePath: action.runReadFile.filepath,
-          offset: action.runReadFile.offset,
-          limit: action.runReadFile.limit
-        });
-      }
-      if (action.runReadFiles) {
-        return this.#readMultiple(action.runReadFiles.filepaths);
-      }
-      if (action.runWriteFile) {
-        return this.#write({
-          filePath: action.runWriteFile.filepath,
-          content: action.runWriteFile.contents
-        });
-      }
-      if (action.runEditFile) {
-        return this.#edit({
-          filePath: action.runEditFile.filepath,
-          oldString: action.runEditFile.oldString,
-          newString: action.runEditFile.newString
-        });
-      }
-      if (action.runShellCommand) {
-        return this.#bash({ command: action.runShellCommand.command });
-      }
-      if (action.runCommand) {
-        const parts = [action.runCommand.program];
-        if (action.runCommand.flags) parts.push(...action.runCommand.flags);
-        if (action.runCommand.arguments) parts.push(...action.runCommand.arguments);
-        return this.#bash({ command: parts.join(" ") });
-      }
-      if (action.runGitCommand) {
-        const cmd = action.runGitCommand.arguments ? `git ${action.runGitCommand.command} ${action.runGitCommand.arguments}` : `git ${action.runGitCommand.command}`;
-        return this.#bash({ command: cmd });
-      }
-      if (action.listDirectory) {
-        return this.#read({ filePath: action.listDirectory.directory });
-      }
-      if (action.grep) {
-        return this.#grep({
-          pattern: action.grep.pattern,
-          path: action.grep.search_directory,
-          caseInsensitive: action.grep.case_insensitive
-        });
-      }
-      if (action.findFiles) {
-        return this.#glob({ pattern: action.findFiles.name_pattern });
-      }
-      if (action.mkdir) {
-        return this.#mkdir(action.mkdir.directory_path);
-      }
-      if (action.runMCPTool) {
-        return this.#executeMcpTool(action.runMCPTool.name, action.runMCPTool.args);
-      }
-      if (action.runHTTPRequest) {
-        return this.#httpRequest(action.runHTTPRequest);
+  if (action.runReadFile) {
+    return {
+      requestId,
+      toolName: "read_file",
+      args: {
+        file_path: action.runReadFile.filepath,
+        offset: action.runReadFile.offset,
+        limit: action.runReadFile.limit
       }
-      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) };
-    }
-  }
-  /**
-   * Execute an MCP tool by name (for runMCPTool actions).
-   * Routes to the appropriate handler based on tool name.
-   */
-  async #executeMcpTool(name, argsJson) {
-    const args = argsJson ? JSON.parse(argsJson) : {};
-    switch (name) {
-      case "bash":
-        return this.#bash(args);
-      case "read":
-        return this.#read(args);
-      case "edit":
-        return this.#edit(args);
-      case "write":
-        return this.#write(args);
-      case "glob":
-        return this.#glob(args);
-      case "grep":
-        return this.#grep(args);
-      default:
-        return { response: "", error: `Unknown MCP tool: ${name}` };
-    }
+    };
   }
-  // ── Handlers ──────────────────────────────────────────────────────
-  async #bash(args) {
-    const cwd = args.workdir ? resolve(this.#cwd, args.workdir) : this.#cwd;
-    const timeout = args.timeout ?? 12e4;
-    return new Promise((res) => {
-      exec(args.command, { cwd, timeout, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
-        const output = [stdout, stderr].filter(Boolean).join("\n");
-        if (error) {
-          res({ response: output, error: error.message });
-          return;
-        }
-        res({ response: output });
-      });
-    });
+  if (action.runReadFiles) {
+    return {
+      requestId,
+      toolName: "read_files",
+      args: { file_paths: action.runReadFiles.filepaths ?? [] }
+    };
   }
-  async #read(args) {
-    try {
-      const filepath = resolve(this.#cwd, args.filePath);
-      const info = await stat(filepath);
-      if (info.isDirectory()) {
-        const entries = await readdir(filepath, { withFileTypes: true });
-        const lines = entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name);
-        return { response: lines.join("\n") };
+  if (action.runWriteFile) {
+    return {
+      requestId,
+      toolName: "create_file_with_contents",
+      args: {
+        file_path: action.runWriteFile.filepath,
+        contents: action.runWriteFile.contents
       }
-      const content = await readFile(filepath, "utf-8");
-      const allLines = content.split("\n");
-      const offset = Math.max((args.offset ?? 1) - 1, 0);
-      const limit = args.limit ?? 2e3;
-      const slice = allLines.slice(offset, offset + limit);
-      const numbered = slice.map((line, i) => `${offset + i + 1}: ${line}`);
-      return { response: numbered.join("\n") };
-    } catch (err) {
-      return { response: "", error: err instanceof Error ? err.message : String(err) };
-    }
+    };
   }
-  async #readMultiple(filepaths) {
-    const results = [];
-    for (const fp of filepaths) {
-      const result = await this.#read({ filePath: fp });
-      if (result.error) {
-        results.push(`--- ${fp} ---
-ERROR: ${result.error}`);
-      } else {
-        results.push(`--- ${fp} ---
-${result.response}`);
+  if (action.runEditFile) {
+    return {
+      requestId,
+      toolName: "edit_file",
+      args: {
+        file_path: action.runEditFile.filepath,
+        old_str: action.runEditFile.oldString,
+        new_str: action.runEditFile.newString
       }
-    }
-    return { response: results.join("\n\n") };
+    };
   }
-  async #edit(args) {
-    try {
-      const filepath = resolve(this.#cwd, args.filePath);
-      let content = await readFile(filepath, "utf-8");
-      if (args.replaceAll) {
-        if (!content.includes(args.oldString)) {
-          return { response: "", error: "oldString not found in content" };
-        }
-        content = content.replaceAll(args.oldString, args.newString);
-      } else {
-        const idx = content.indexOf(args.oldString);
-        if (idx === -1) {
-          return { response: "", error: "oldString not found in content" };
-        }
-        const secondIdx = content.indexOf(args.oldString, idx + 1);
-        if (secondIdx !== -1) {
-          return { response: "", error: "Found multiple matches for oldString. Provide more surrounding lines to identify the correct match." };
-        }
-        content = content.slice(0, idx) + args.newString + content.slice(idx + args.oldString.length);
-      }
-      await writeFile(filepath, content, "utf-8");
-      return { response: `Successfully edited ${args.filePath}` };
-    } catch (err) {
-      return { response: "", error: err instanceof Error ? err.message : String(err) };
-    }
+  if (action.findFiles) {
+    return {
+      requestId,
+      toolName: "find_files",
+      args: { name_pattern: action.findFiles.name_pattern }
+    };
   }
-  async #write(args) {
-    try {
-      const filepath = resolve(this.#cwd, args.filePath);
-      await fsMkdir(dirname(filepath), { recursive: true });
-      await writeFile(filepath, args.content, "utf-8");
-      return { response: `Successfully wrote ${args.filePath}` };
-    } catch (err) {
-      return { response: "", error: err instanceof Error ? err.message : String(err) };
-    }
+  if (action.listDirectory) {
+    return {
+      requestId,
+      toolName: "list_dir",
+      args: { directory: action.listDirectory.directory }
+    };
   }
-  async #glob(args) {
-    const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
-    return new Promise((res) => {
-      const command = process.platform === "win32" ? `dir /s /b "${args.pattern}"` : `find . -path "./${args.pattern}" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -200`;
-      exec(command, { cwd, timeout: 3e4 }, (error, stdout) => {
-        if (error && !stdout) {
-          exec(`ls -1 ${args.pattern} 2>/dev/null | head -200`, { cwd, timeout: 3e4 }, (_err, out) => {
-            res({ response: out.trim() || "No matches found" });
-          });
-          return;
-        }
-        const lines = stdout.trim().split("\n").filter(Boolean);
-        res({ response: lines.length > 0 ? lines.join("\n") : "No matches found" });
-      });
-    });
+  if (action.grep) {
+    const args = { pattern: action.grep.pattern };
+    if (action.grep.search_directory) args.search_directory = action.grep.search_directory;
+    if (action.grep.case_insensitive !== void 0) args.case_insensitive = action.grep.case_insensitive;
+    return { requestId, toolName: "grep", args };
   }
-  async #grep(args) {
-    const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
-    const caseFlag = args.caseInsensitive ? "--ignore-case" : "";
-    return new Promise((res) => {
-      const includeFlag = args.include ? `--glob '${args.include}'` : "";
-      const escapedPattern = args.pattern.replace(/'/g, "'\\''");
-      const rgCommand = `rg --line-number --no-heading ${caseFlag} ${includeFlag} '${escapedPattern}' . 2>/dev/null | head -500`;
-      exec(rgCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (_error, stdout) => {
-        if (stdout.trim()) {
-          res({ response: stdout.trim() });
-          return;
-        }
-        const grepCaseFlag = args.caseInsensitive ? "-i" : "";
-        const grepInclude = args.include ? `--include='${args.include}'` : "";
-        const grepCommand = `grep -rn ${grepCaseFlag} ${grepInclude} '${escapedPattern}' . 2>/dev/null | head -500`;
-        exec(grepCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (_err, out) => {
-          res({ response: out.trim() || "No matches found" });
-        });
-      });
-    });
+  if (action.mkdir) {
+    return {
+      requestId,
+      toolName: "mkdir",
+      args: { directory_path: action.mkdir.directory_path }
+    };
   }
-  async #mkdir(directoryPath) {
-    try {
-      const filepath = resolve(this.#cwd, directoryPath);
-      await fsMkdir(filepath, { recursive: true });
-      return { response: `Created directory ${directoryPath}` };
-    } catch (err) {
-      return { response: "", error: err instanceof Error ? err.message : String(err) };
-    }
+  if (action.runShellCommand) {
+    return {
+      requestId,
+      toolName: "shell_command",
+      args: { command: action.runShellCommand.command }
+    };
   }
-  async #httpRequest(args) {
-    if (!this.#client) {
-      return { response: "", error: "HTTP requests require GitLab client credentials" };
-    }
-    try {
-      const url = `${this.#client.instanceUrl}/api/v4/${args.path}`;
-      const headers = {
-        authorization: `Bearer ${this.#client.token}`
-      };
-      if (args.body) {
-        headers["content-type"] = "application/json";
+  if (action.runCommand) {
+    return {
+      requestId,
+      toolName: "run_command",
+      args: {
+        program: action.runCommand.program,
+        flags: action.runCommand.flags,
+        arguments: action.runCommand.arguments
       }
-      const response = await fetch(url, {
-        method: args.method,
-        headers,
-        body: args.body ?? void 0
-      });
-      const text2 = await response.text();
-      if (!response.ok) {
-        return { response: text2, error: `HTTP ${response.status}: ${response.statusText}` };
+    };
+  }
+  if (action.runGitCommand) {
+    return {
+      requestId,
+      toolName: "run_git_command",
+      args: {
+        repository_url: action.runGitCommand.repository_url ?? "",
+        command: action.runGitCommand.command,
+        args: action.runGitCommand.arguments
       }
-      return { response: text2 };
-    } catch (err) {
-      return { response: "", error: err instanceof Error ? err.message : String(err) };
-    }
+    };
   }
-};
+  if (action.runHTTPRequest) {
+    return {
+      requestId,
+      toolName: "gitlab_api_request",
+      args: {
+        method: action.runHTTPRequest.method,
+        path: action.runHTTPRequest.path,
+        body: action.runHTTPRequest.body
+      }
+    };
+  }
+  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 {
@@ -1031,7 +798,6 @@ var WorkflowSession = class {
   #rootNamespaceId;
   #checkpoint = createCheckpointState();
   #toolsConfig;
-  #toolExecutor;
   #socket;
   #queue;
   #startRequestSent = false;
@@ -1040,7 +806,6 @@ var WorkflowSession = class {
     this.#tokenService = new WorkflowTokenService(client);
     this.#modelId = modelId;
     this.#cwd = cwd;
-    this.#toolExecutor = new ToolExecutor(cwd, client);
   }
   /**
    * Opt-in: override the server-side system prompt and/or register MCP tools.
@@ -1118,8 +883,11 @@ var WorkflowSession = class {
    * Send a tool result back to DWS on the existing connection.
    */
   sendToolResult(requestId, output, error) {
-    if (!this.#socket) throw new Error("Not connected");
-    console.error(`[duo-workflow] sendToolResult: requestId=${requestId} output=${output.length} bytes, error=${error ?? "none"}`);
+    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"}`);
     this.#socket.send({
       actionResponse: {
         requestID: requestId,
@@ -1135,7 +903,10 @@ var WorkflowSession = class {
    * Returns null when the stream is closed (turn complete or connection lost).
    */
   async waitForEvent() {
-    if (!this.#queue) return null;
+    if (!this.#queue) {
+      dlog("waitForEvent: queue=null");
+      return null;
+    }
     return this.#queue.shift();
   }
   /**
@@ -1171,24 +942,18 @@ var WorkflowSession = class {
       }
       return;
     }
-    if (action.requestID) {
-      console.error(`[duo-workflow] ws tool action: keys=${JSON.stringify(Object.keys(action).filter((k) => k !== "requestID"))}`);
-      this.#executeStandaloneAction(action);
+    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,
+        toolName: mapped.toolName,
+        args: mapped.args
+      });
     }
   }
-  async #executeStandaloneAction(action) {
-    if (!action.requestID || !this.#socket) return;
-    const result = await this.#toolExecutor.executeAction(action);
-    this.#socket.send({
-      actionResponse: {
-        requestID: action.requestID,
-        plainTextResponse: {
-          response: result.response,
-          error: result.error ?? ""
-        }
-      }
-    });
-  }
   // ---------------------------------------------------------------------------
   // Private: connection management
   // ---------------------------------------------------------------------------
@@ -1270,21 +1035,21 @@ function extractToolResults(prompt) {
         const toolName = String(p.toolName ?? "");
         if (!toolCallId) continue;
         const { output, error } = parseToolResultOutput(p);
-        const finalError = error ?? asString2(p.error) ?? asString2(p.errorText);
+        const finalError = error ?? asString(p.error) ?? asString(p.errorText);
         results.push({ toolCallId, toolName, output, error: finalError });
       }
       if (p.type === "tool-error") {
         const toolCallId = String(p.toolCallId ?? "");
         const toolName = String(p.toolName ?? "");
         const errorValue = p.error ?? p.errorText ?? p.message;
-        const error = asString2(errorValue) ?? String(errorValue ?? "");
+        const error = asString(errorValue) ?? String(errorValue ?? "");
         results.push({ toolCallId, toolName, output: "", error });
       }
     }
   }
   return results;
 }
-function asString2(value) {
+function asString(value) {
   return typeof value === "string" ? value : void 0;
 }
 function parseToolResultOutput(part) {
@@ -1309,7 +1074,7 @@ function parseToolResultOutput(part) {
   }
   if (resultField !== void 0) {
     const output = typeof resultField === "string" ? resultField : JSON.stringify(resultField);
-    const error = isPlainObject(resultField) ? asString2(resultField.error) : void 0;
+    const error = isPlainObject(resultField) ? asString(resultField.error) : void 0;
     return { output, error };
   }
   return { output: "" };
@@ -1377,14 +1142,14 @@ function isPlainObject(value) {
 function mapDuoToolRequest(toolName, args) {
   switch (toolName) {
     case "list_dir": {
-      const directory = asString3(args.directory) ?? ".";
+      const directory = asString2(args.directory) ?? ".";
       return {
         toolName: "bash",
         args: { command: `ls -la ${shellQuote(directory)}`, description: "List directory contents", workdir: "." }
       };
     }
     case "read_file": {
-      const filePath = asString3(args.file_path) ?? asString3(args.filepath) ?? asString3(args.filePath) ?? asString3(args.path);
+      const filePath = asString2(args.file_path) ?? asString2(args.filepath) ?? asString2(args.filePath) ?? asString2(args.path);
       if (!filePath) return { toolName, args };
       const mapped = { filePath };
       if (typeof args.offset === "number") mapped.offset = args.offset;
@@ -1392,32 +1157,32 @@ function mapDuoToolRequest(toolName, args) {
       return { toolName: "read", args: mapped };
     }
     case "read_files": {
-      const filePaths = asStringArray2(args.file_paths);
+      const filePaths = asStringArray(args.file_paths);
       if (filePaths.length === 0) return { toolName, args };
       return filePaths.map((fp) => ({ toolName: "read", args: { filePath: fp } }));
     }
     case "create_file_with_contents": {
-      const filePath = asString3(args.file_path);
-      const content = asString3(args.contents);
+      const filePath = asString2(args.file_path);
+      const content = asString2(args.contents);
       if (!filePath || content === void 0) return { toolName, args };
       return { toolName: "write", args: { filePath, content } };
     }
     case "edit_file": {
-      const filePath = asString3(args.file_path);
-      const oldString = asString3(args.old_str);
-      const newString = asString3(args.new_str);
+      const filePath = asString2(args.file_path);
+      const oldString = asString2(args.old_str);
+      const newString = asString2(args.new_str);
       if (!filePath || oldString === void 0 || newString === void 0) return { toolName, args };
       return { toolName: "edit", args: { filePath, oldString, newString } };
     }
     case "find_files": {
-      const pattern = asString3(args.name_pattern);
+      const pattern = asString2(args.name_pattern);
       if (!pattern) return { toolName, args };
       return { toolName: "glob", args: { pattern } };
     }
     case "grep": {
-      const pattern = asString3(args.pattern);
+      const pattern = asString2(args.pattern);
       if (!pattern) return { toolName, args };
-      const searchDir = asString3(args.search_directory);
+      const searchDir = asString2(args.search_directory);
       const caseInsensitive = Boolean(args.case_insensitive);
       const normalizedPattern = caseInsensitive && !pattern.startsWith("(?i)") ? `(?i)${pattern}` : pattern;
       const mapped = { pattern: normalizedPattern };
@@ -1425,43 +1190,67 @@ function mapDuoToolRequest(toolName, args) {
       return { toolName: "grep", args: mapped };
     }
     case "mkdir": {
-      const directory = asString3(args.directory_path);
+      const directory = asString2(args.directory_path);
       if (!directory) return { toolName, args };
       return { toolName: "bash", args: { command: `mkdir -p ${shellQuote(directory)}`, description: "Create directory", workdir: "." } };
     }
     case "shell_command": {
-      const command = asString3(args.command);
+      const command = asString2(args.command);
       if (!command) return { toolName, args };
       return { toolName: "bash", args: { command, description: "Run shell command", workdir: "." } };
     }
     case "run_command": {
-      const program = asString3(args.program);
+      const program = asString2(args.program);
       if (program) {
         const parts = [shellQuote(program)];
         if (Array.isArray(args.flags)) parts.push(...args.flags.map((f) => shellQuote(String(f))));
         if (Array.isArray(args.arguments)) parts.push(...args.arguments.map((a) => shellQuote(String(a))));
         return { toolName: "bash", args: { command: parts.join(" "), description: "Run command", workdir: "." } };
       }
-      const command = asString3(args.command);
+      const command = asString2(args.command);
       if (!command) return { toolName, args };
       return { toolName: "bash", args: { command, description: "Run command", workdir: "." } };
     }
     case "run_git_command": {
-      const command = asString3(args.command);
+      const command = asString2(args.command);
       if (!command) return { toolName, args };
       const rawArgs = args.args;
-      const extraArgs = Array.isArray(rawArgs) ? rawArgs.map((v) => shellQuote(String(v))).join(" ") : asString3(rawArgs);
+      const extraArgs = Array.isArray(rawArgs) ? rawArgs.map((v) => shellQuote(String(v))).join(" ") : asString2(rawArgs);
       const gitCmd = extraArgs ? `git ${shellQuote(command)} ${extraArgs}` : `git ${shellQuote(command)}`;
       return { toolName: "bash", args: { command: gitCmd, description: "Run git command", workdir: "." } };
     }
+    case "gitlab_api_request": {
+      const method = asString2(args.method) ?? "GET";
+      const apiPath = asString2(args.path);
+      if (!apiPath) return { toolName, args };
+      const body = asString2(args.body);
+      const curlParts = [
+        "curl",
+        "-s",
+        "-X",
+        method,
+        "-H",
+        "'Authorization: Bearer $GITLAB_TOKEN'",
+        "-H",
+        "'Content-Type: application/json'"
+      ];
+      if (body) {
+        curlParts.push("-d", shellQuote(body));
+      }
+      curlParts.push(shellQuote(`$GITLAB_INSTANCE_URL/api/v4/${apiPath}`));
+      return {
+        toolName: "bash",
+        args: { command: curlParts.join(" "), description: `GitLab API: ${method} ${apiPath}`, workdir: "." }
+      };
+    }
     default:
       return { toolName, args };
   }
 }
-function asString3(value) {
+function asString2(value) {
   return typeof value === "string" ? value : void 0;
 }
-function asStringArray2(value) {
+function asStringArray(value) {
   if (!Array.isArray(value)) return [];
   return value.filter((v) => typeof v === "string");
 }
@@ -1626,6 +1415,7 @@ 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();
@@ -1679,9 +1469,11 @@ 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);
@@ -1732,7 +1524,10 @@ var DuoWorkflowModel = class {
             let hasText = false;
             while (true) {
               const event = await session.waitForEvent();
-              if (!event) break;
+              if (!event) {
+                dlog("phase3: event=null (queue closed)");
+                break;
+              }
               if (event.type === "text-delta") {
                 if (!event.value) continue;
                 if (!hasText) {
@@ -1746,7 +1541,10 @@ 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) {

package/package.json

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