opencode-gitlab-duo-agentic 0.2.1 → 0.2.4

package/dist/index.js

@@ -10,7 +10,6 @@ var WORKFLOW_CONNECT_TIMEOUT_MS = 15e3;
 var WORKFLOW_HEARTBEAT_INTERVAL_MS = 6e4;
 var WORKFLOW_KEEPALIVE_INTERVAL_MS = 45e3;
 var WORKFLOW_TOKEN_EXPIRY_BUFFER_MS = 3e4;
-var WORKFLOW_TOOL_ERROR_MESSAGE = "Tool execution is not implemented in this client yet";
 
 // src/gitlab/models.ts
 import crypto from "crypto";
@@ -343,236 +342,8 @@ function toModelsConfig(available) {
   return out;
 }
 
-// src/workflow/opencode-tools.ts
-var SUPPORTED_TOOLS = /* @__PURE__ */ new Set([
-  "bash",
-  "read",
-  "edit",
-  "write",
-  "glob",
-  "grep"
-]);
-async function fetchOpencodeTools(client, provider, model) {
-  try {
-    const response = await client.tool.list({ provider, model });
-    const tools = response.data ?? [];
-    return tools.filter((t) => SUPPORTED_TOOLS.has(t.id)).map((t) => ({
-      name: t.id,
-      description: t.description,
-      inputSchema: typeof t.parameters === "string" ? t.parameters : JSON.stringify(t.parameters)
-    }));
-  } catch {
-    return [];
-  }
-}
-function buildFallbackTools() {
-  return [
-    {
-      name: "bash",
-      description: "Execute a shell command. Use the `command` parameter for the command to run, `description` for a short summary, optional `timeout` in milliseconds, and optional `workdir` to set the working directory.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          command: { type: "string", description: "The command to execute" },
-          description: { type: "string", description: "Clear, concise description of what this command does in 5-10 words" },
-          timeout: { type: "number", description: "Optional timeout in milliseconds" },
-          workdir: { type: "string", description: "The working directory to run the command in" }
-        },
-        required: ["command", "description"]
-      })
-    },
-    {
-      name: "read",
-      description: "Read a file or directory from the local filesystem. Returns content with line numbers prefixed. Supports offset and limit for pagination. Can read images and PDFs as attachments.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          filePath: { type: "string", description: "The absolute path to the file or directory to read" },
-          offset: { type: "number", description: "The line number to start reading from (1-indexed)" },
-          limit: { type: "number", description: "The maximum number of lines to read (defaults to 2000)" }
-        },
-        required: ["filePath"]
-      })
-    },
-    {
-      name: "edit",
-      description: "Performs exact string replacements in files. The oldString must match the file contents exactly. Provide surrounding context to make the match unique.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          filePath: { type: "string", description: "The absolute path to the file to modify" },
-          oldString: { type: "string", description: "The text to replace" },
-          newString: { type: "string", description: "The text to replace it with" },
-          replaceAll: { type: "boolean", description: "Replace all occurrences (default false)" }
-        },
-        required: ["filePath", "oldString", "newString"]
-      })
-    },
-    {
-      name: "write",
-      description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Parent directories are created automatically.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          filePath: { type: "string", description: "The absolute path to the file to write" },
-          content: { type: "string", description: "The content to write to the file" }
-        },
-        required: ["filePath", "content"]
-      })
-    },
-    {
-      name: "glob",
-      description: "Fast file pattern matching. Supports glob patterns like '**/*.js' or 'src/**/*.ts'. Returns matching file paths sorted by modification time.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "The glob pattern to match files against" },
-          path: { type: "string", description: "The directory to search in" }
-        },
-        required: ["pattern"]
-      })
-    },
-    {
-      name: "grep",
-      description: "Fast content search using regular expressions. Returns file paths and line numbers with matches. Supports filtering files by pattern with the include parameter.",
-      inputSchema: JSON.stringify({
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "The regex pattern to search for in file contents" },
-          path: { type: "string", description: "The directory to search in" },
-          include: { type: "string", description: "File pattern to include in the search (e.g. '*.js', '*.{ts,tsx}')" }
-        },
-        required: ["pattern"]
-      })
-    }
-  ];
-}
-
-// src/workflow/flow-config.ts
-function buildFlowConfig(systemPrompt) {
-  return {
-    version: "v1",
-    environment: "chat-partial",
-    components: [
-      {
-        name: "opencode_agent",
-        type: "AgentComponent",
-        // Empty toolset: we rely entirely on MCP tools (OpenCode tools)
-        // registered via the mcpTools field in startRequest
-        toolset: []
-      }
-    ],
-    prompts: [
-      {
-        name: "opencode_prompt",
-        prompt_id: "opencode_prompt",
-        model: {
-          params: {
-            model_class_provider: "anthropic",
-            max_tokens: 32768
-          }
-        },
-        unit_primitives: ["duo_chat"],
-        prompt_template: {
-          system: systemPrompt,
-          user: "{{goal}}",
-          placeholder: "history"
-        }
-      }
-    ]
-  };
-}
-var OPENCODE_SYSTEM_PROMPT = `You are OpenCode, an AI coding assistant integrated with GitLab Duo.
-
-<core_mission>
-Your primary role is collaborative programming - working alongside the user to accomplish coding objectives using the tools available to you.
-</core_mission>
-
-<communication_guidelines>
-- Provide clear and concise responses. Brevity and clarity are critical.
-- Focus on clean, practical solutions that help users make progress.
-- Keep responses brief and to the point. One-word answers are fine when they suffice.
-- Use active, present-tense language: 'Analyzing...', 'Processing...' instead of 'Let me...', 'I will...'
-- When unable to complete requests, explain the limitation concisely and provide alternatives.
-- When users correct you, acknowledge briefly and apply the correction immediately.
-</communication_guidelines>
-
-<tool_usage>
-You have access to file system and shell tools. Use them effectively:
-
-- Use the 'read' tool to read files before editing them.
-- Use the 'edit' tool for precise string replacements in existing files.
-- Use the 'write' tool to create new files or overwrite existing ones.
-- Use the 'glob' tool to find files by name patterns.
-- Use the 'grep' tool to search file contents with regex.
-- Use the 'bash' tool for shell commands (git, npm, docker, tests, builds, etc.).
-
-Tool orchestration:
-- Execute multiple independent tool operations in parallel when possible.
-- Read files before modifying them to understand context.
-- Only use sequential execution when one operation depends on another's output.
-- Plan your information needs upfront and execute searches together.
-</tool_usage>
-
-<code_analysis>
-Before writing any code:
-1. Read existing files to understand context and preserve important logic.
-2. Check dependencies exist before importing.
-3. Match existing patterns: import style, naming conventions, component structure, error handling.
-</code_analysis>
-
-<code_standards>
-- Write high-quality, general purpose solutions that work for all valid inputs.
-- Make code immediately executable. No placeholders like "TODO: implement this".
-- Match existing patterns in the codebase.
-- Follow the project's established error handling approach.
-- Verify changes work as expected before completing the task.
-</code_standards>
-
-<file_guidelines>
-- ALWAYS prefer editing existing files over creating new ones.
-- NEVER create documentation files unless explicitly requested.
-- Use extended thinking for complex tasks rather than creating temporary files.
-</file_guidelines>
-
-<git_guidelines>
-When working with git:
-- Only create commits when explicitly requested by the user.
-- NEVER run destructive git commands (push --force, hard reset) unless explicitly requested.
-- NEVER skip hooks unless explicitly requested.
-- Draft concise commit messages that focus on the "why" rather than the "what".
-- Do not push to remote unless explicitly asked.
-</git_guidelines>`;
-
-// src/workflow/tools-config-store.ts
-var stored;
-function setToolsConfig(config) {
-  stored = config;
-}
-function getToolsConfig() {
-  return stored;
-}
-
 // src/plugin/hooks.ts
-async function initializeToolsConfig(input) {
-  let mcpTools = await fetchOpencodeTools(
-    input.client,
-    "gitlab",
-    "duo-chat-sonnet-4-5"
-  );
-  if (mcpTools.length === 0) {
-    mcpTools = buildFallbackTools();
-  }
-  const flowConfig = buildFlowConfig(OPENCODE_SYSTEM_PROMPT);
-  setToolsConfig({
-    mcpTools,
-    flowConfig,
-    flowConfigSchemaVersion: "v1"
-  });
-}
 async function createPluginHooks(input) {
-  initializeToolsConfig(input).catch(() => {
-  });
   return {
     config: async (config) => applyRuntimeConfig(config, input.directory),
     "chat.message": async ({ sessionID }, { parts }) => {
@@ -620,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 {
@@ -645,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) {
@@ -672,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 {
@@ -746,9 +536,6 @@ var WORKFLOW_STATUS = {
 function isCheckpointAction(action) {
   return "newCheckpoint" in action && action.newCheckpoint != null;
 }
-function isMcpToolAction(action) {
-  return "runMCPTool" in action && action.runMCPTool != null;
-}
 var TURN_COMPLETE_STATUSES = /* @__PURE__ */ new Set([
   WORKFLOW_STATUS.INPUT_REQUIRED,
   WORKFLOW_STATUS.FINISHED,
@@ -853,15 +640,198 @@ function decodeSocketMessage(data) {
 }
 
 // src/workflow/tool-executor.ts
-import { readFile, readdir, writeFile, mkdir, stat } from "fs/promises";
+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;
-  constructor(cwd) {
+  #client;
+  constructor(cwd, client) {
     this.#cwd = cwd;
+    this.#client = client;
   }
-  async execute(name, argsJson) {
+  /**
+   * 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 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);
+      }
+      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":
@@ -877,21 +847,21 @@ var ToolExecutor = class {
       case "grep":
         return this.#grep(args);
       default:
-        return { response: "", error: `Unknown tool: ${name}` };
+        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((resolve2) => {
+    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) {
-          const output2 = [stdout, stderr].filter(Boolean).join("\n");
-          resolve2({ response: output2, error: error.message });
+          res({ response: output, error: error.message });
           return;
         }
-        const output = [stdout, stderr].filter(Boolean).join("\n");
-        resolve2({ response: output });
+        res({ response: output });
       });
     });
   }
@@ -915,6 +885,20 @@ var ToolExecutor = class {
       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}`);
+      }
+    }
+    return { response: results.join("\n\n") };
+  }
   async #edit(args) {
     try {
       const filepath = resolve(this.#cwd, args.filePath);
@@ -944,7 +928,7 @@ var ToolExecutor = class {
   async #write(args) {
     try {
       const filepath = resolve(this.#cwd, args.filePath);
-      await mkdir(dirname(filepath), { recursive: true });
+      await fsMkdir(dirname(filepath), { recursive: true });
       await writeFile(filepath, args.content, "utf-8");
       return { response: `Successfully wrote ${args.filePath}` };
     } catch (err) {
@@ -953,38 +937,76 @@ var ToolExecutor = class {
   }
   async #glob(args) {
     const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
-    return new Promise((resolve2) => {
+    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) => {
-            resolve2({ response: out.trim() || "No matches found" });
+            res({ response: out.trim() || "No matches found" });
           });
           return;
         }
         const lines = stdout.trim().split("\n").filter(Boolean);
-        resolve2({ response: lines.length > 0 ? lines.join("\n") : "No matches found" });
+        res({ response: lines.length > 0 ? lines.join("\n") : "No matches found" });
       });
     });
   }
   async #grep(args) {
     const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
-    return new Promise((resolve2) => {
+    const caseFlag = args.caseInsensitive ? "--ignore-case" : "";
+    return new Promise((res) => {
       const includeFlag = args.include ? `--glob '${args.include}'` : "";
-      const rgCommand = `rg --line-number --no-heading ${includeFlag} '${args.pattern.replace(/'/g, "'\\''")}' . 2>/dev/null | head -500`;
-      exec(rgCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (error, stdout) => {
+      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()) {
-          resolve2({ response: stdout.trim() });
+          res({ response: stdout.trim() });
           return;
         }
+        const grepCaseFlag = args.caseInsensitive ? "-i" : "";
         const grepInclude = args.include ? `--include='${args.include}'` : "";
-        const grepCommand = `grep -rn ${grepInclude} '${args.pattern.replace(/'/g, "'\\''")}' . 2>/dev/null | head -500`;
+        const grepCommand = `grep -rn ${grepCaseFlag} ${grepInclude} '${escapedPattern}' . 2>/dev/null | head -500`;
         exec(grepCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (_err, out) => {
-          resolve2({ response: out.trim() || "No matches found" });
+          res({ response: out.trim() || "No matches found" });
         });
       });
     });
   }
+  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) };
+    }
+  }
+  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";
+      }
+      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}` };
+      }
+      return { response: text2 };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
 };
 
 // src/workflow/session.ts
@@ -1006,8 +1028,12 @@ var WorkflowSession = class {
     this.#tokenService = new WorkflowTokenService(client);
     this.#modelId = modelId;
     this.#cwd = cwd;
-    this.#toolExecutor = new ToolExecutor(cwd);
+    this.#toolExecutor = new ToolExecutor(cwd, client);
   }
+  /**
+   * Opt-in: override the server-side system prompt and/or register MCP tools.
+   * When not called, the server uses its default prompt and built-in tools.
+   */
   setToolsConfig(config) {
     this.#toolsConfig = config;
   }
@@ -1047,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 });
@@ -1062,10 +1088,11 @@ var WorkflowSession = class {
           workflowMetadata: JSON.stringify({
             extended_logging: access?.workflow_metadata?.extended_logging ?? false
           }),
-          clientCapabilities: [],
+          clientCapabilities: ["shell_command"],
           mcpTools,
           additional_context: [],
           preapproved_tools: preapprovedTools,
+          // Only include flowConfig when explicitly configured (opt-in prompt override)
           ...this.#toolsConfig?.flowConfig ? {
             flowConfig: this.#toolsConfig.flowConfig,
             flowConfigSchemaVersion: this.#toolsConfig.flowConfigSchemaVersion ?? "v1"
@@ -1081,39 +1108,48 @@ 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;
-        if (isMcpToolAction(event.action)) {
-          const { name, args } = event.action.runMCPTool;
-          const result = await this.#toolExecutor.execute(name, args);
-          socket.send({
-            actionResponse: {
-              requestID: event.action.requestID,
-              plainTextResponse: {
-                response: result.response,
-                error: result.error ?? ""
-              }
-            }
-          });
+        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,
             plainTextResponse: {
-              response: "",
-              error: WORKFLOW_TOOL_ERROR_MESSAGE
+              response: result.response,
+              error: result.error ?? ""
             }
           }
         });
@@ -1224,7 +1260,11 @@ var DuoWorkflowModel = class {
     this.#client = client;
     this.#cwd = cwd ?? process.cwd();
   }
-  /** Set the tools configuration for new and existing sessions. */
+  /**
+   * Opt-in: override the server-side system prompt and/or register MCP tools.
+   * When not called, the server uses its default prompt and built-in tools.
+   * Tool execution is always bridged locally regardless of this setting.
+   */
   setToolsConfig(config) {
     this.#toolsConfig = config;
     for (const session of sessions.values()) {
@@ -1259,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) => {
@@ -1328,8 +1368,7 @@ var DuoWorkflowModel = class {
     const existing = sessions.get(key);
     if (existing) return existing;
     const created = new WorkflowSession(this.#client, this.modelId, this.#cwd);
-    const config = this.#toolsConfig ?? getToolsConfig();
-    if (config) created.setToolsConfig(config);
+    if (this.#toolsConfig) created.setToolsConfig(this.#toolsConfig);
     sessions.set(key, created);
     return created;
   }

package/package.json

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