opencode-gitlab-duo-agentic 0.2.5 → 0.2.7

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,131 @@ 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/workflow/session.ts
 var WorkflowSession = class {
@@ -1031,7 +787,6 @@ var WorkflowSession = class {
   #rootNamespaceId;
   #checkpoint = createCheckpointState();
   #toolsConfig;
-  #toolExecutor;
   #socket;
   #queue;
   #startRequestSent = false;
@@ -1040,7 +795,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.
@@ -1089,7 +843,7 @@ var WorkflowSession = class {
   // ---------------------------------------------------------------------------
   // Messaging
   // ---------------------------------------------------------------------------
-  sendStartRequest(goal) {
+  sendStartRequest(goal, additionalContext = []) {
     if (!this.#socket || !this.#workflowId) throw new Error("Not connected");
     const mcpTools = this.#toolsConfig?.mcpTools ?? [];
     const preapprovedTools = mcpTools.map((t) => t.name);
@@ -1104,7 +858,7 @@ var WorkflowSession = class {
         }),
         clientCapabilities: ["shell_command"],
         mcpTools,
-        additional_context: [],
+        additional_context: additionalContext,
         preapproved_tools: preapprovedTools,
         ...this.#toolsConfig?.flowConfig ? {
           flowConfig: this.#toolsConfig.flowConfig,
@@ -1171,24 +925,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) {
+      console.error(`[duo-workflow] ws tool request: ${mapped.toolName} requestId=${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
   // ---------------------------------------------------------------------------
@@ -1265,16 +1013,28 @@ function extractToolResults(prompt) {
     if (!Array.isArray(content)) continue;
     for (const part of content) {
       const p = part;
-      if (p.type !== "tool-result") continue;
-      const toolCallId = String(p.toolCallId ?? "");
-      const toolName = String(p.toolName ?? "");
-      if (!toolCallId) continue;
-      const { output, error } = parseToolResultOutput(p);
-      results.push({ toolCallId, toolName, output, error });
+      if (p.type === "tool-result") {
+        const toolCallId = String(p.toolCallId ?? "");
+        const toolName = String(p.toolName ?? "");
+        if (!toolCallId) continue;
+        const { output, error } = parseToolResultOutput(p);
+        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 = asString(errorValue) ?? String(errorValue ?? "");
+        results.push({ toolCallId, toolName, output: "", error });
+      }
     }
   }
   return results;
 }
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
 function parseToolResultOutput(part) {
   const outputField = part.output;
   const resultField = part.result;
@@ -1296,10 +1056,67 @@ function parseToolResultOutput(part) {
     return { output: typeof outputField === "string" ? outputField : JSON.stringify(outputField) };
   }
   if (resultField !== void 0) {
-    return { output: typeof resultField === "string" ? resultField : JSON.stringify(resultField) };
+    const output = typeof resultField === "string" ? resultField : JSON.stringify(resultField);
+    const error = isPlainObject(resultField) ? asString(resultField.error) : void 0;
+    return { output, error };
   }
   return { output: "" };
 }
+function extractSystemPrompt(prompt) {
+  if (!Array.isArray(prompt)) return null;
+  const parts = [];
+  for (const message of prompt) {
+    const msg = message;
+    if (msg.role === "system" && typeof msg.content === "string" && msg.content.trim()) {
+      parts.push(msg.content);
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+function sanitizeSystemPrompt(prompt) {
+  let result = prompt;
+  result = result.replace(/^You are [Oo]pen[Cc]ode[,.].*$/gm, "");
+  result = result.replace(/^Your name is opencode\s*$/gm, "");
+  result = result.replace(
+    /If the user asks for help or wants to give feedback[\s\S]*?https:\/\/github\.com\/anomalyco\/opencode\s*/g,
+    ""
+  );
+  result = result.replace(
+    /When the user directly asks about OpenCode[\s\S]*?https:\/\/opencode\.ai\/docs\s*/g,
+    ""
+  );
+  result = result.replace(/https:\/\/github\.com\/anomalyco\/opencode\S*/g, "");
+  result = result.replace(/https:\/\/opencode\.ai\S*/g, "");
+  result = result.replace(/\bOpenCode\b/g, "GitLab Duo");
+  result = result.replace(/\bopencode\b/g, "GitLab Duo");
+  result = result.replace(/The exact model ID is GitLab Duo\//g, "The exact model ID is ");
+  result = result.replace(/\n{3,}/g, "\n\n");
+  return result.trim();
+}
+function extractAgentReminders(prompt) {
+  if (!Array.isArray(prompt)) return [];
+  let textParts = [];
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const message = prompt[i];
+    if (message?.role !== "user" || !Array.isArray(message.content)) continue;
+    textParts = message.content.filter((p) => p.type === "text");
+    if (textParts.length > 0) break;
+  }
+  if (textParts.length === 0) return [];
+  const reminders = [];
+  for (const part of textParts) {
+    if (!part.text) continue;
+    const text2 = String(part.text);
+    if (part.synthetic) {
+      const trimmed = text2.trim();
+      if (trimmed.length > 0) reminders.push(trimmed);
+      continue;
+    }
+    const matches = text2.match(/<system-reminder>[\s\S]*?<\/system-reminder>/g);
+    if (matches) reminders.push(...matches);
+  }
+  return reminders;
+}
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1323,7 +1140,7 @@ 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 } }));
     }
@@ -1385,6 +1202,30 @@ function mapDuoToolRequest(toolName, args) {
       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 };
   }
@@ -1392,7 +1233,7 @@ function mapDuoToolRequest(toolName, args) {
 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");
 }
@@ -1421,6 +1262,85 @@ function readProviderBlock(options) {
   return void 0;
 }
 
+// src/provider/system-context.ts
+import os2 from "os";
+function buildSystemContext() {
+  const platform = os2.platform();
+  const arch = os2.arch();
+  return [
+    {
+      category: "os_information",
+      content: `<os><platform>${platform}</platform><architecture>${arch}</architecture></os>`,
+      id: "os_information",
+      metadata: JSON.stringify({
+        title: "Operating System",
+        enabled: true,
+        subType: "os"
+      })
+    },
+    {
+      category: "user_rule",
+      content: SYSTEM_RULES,
+      id: "user_rules",
+      metadata: JSON.stringify({
+        title: "System Rules",
+        enabled: true,
+        subType: "user_rule"
+      })
+    }
+  ];
+}
+var SYSTEM_RULES = `<system-reminder>
+You MUST follow ALL the rules in this block strictly.
+
+<tool_orchestration>
+PARALLEL EXECUTION:
+- When gathering information, plan all needed searches upfront and execute
+  them together using multiple tool calls in the same turn where possible.
+- Read multiple related files together rather than one at a time.
+- Patterns: grep + find_files together, read_file for multiple files together.
+
+SEQUENTIAL EXECUTION (only when output depends on previous step):
+- Read a file BEFORE editing it (always).
+- Check dependencies BEFORE importing them.
+- Run tests AFTER making changes.
+
+READ BEFORE WRITE:
+- Always read existing files before modifying them to understand context.
+- Check for existing patterns (naming, imports, error handling) and match them.
+- Verify the exact content to replace when using edit_file.
+
+ERROR HANDLING:
+- If a tool fails, analyze the error before retrying.
+- If a shell command fails, check the error output and adapt.
+- Do not repeat the same failing operation without changes.
+</tool_orchestration>
+
+<development_workflow>
+For software development tasks, follow this workflow:
+
+1. UNDERSTAND: Read relevant files, explore the codebase structure
+2. PLAN: Break down the task into clear steps
+3. IMPLEMENT: Make changes methodically, one step at a time
+4. VERIFY: Run tests, type-checking, or build to validate changes
+5. COMPLETE: Summarize what was accomplished
+
+CODE QUALITY:
+- Match existing code style and patterns in the project
+- Write immediately executable code (no TODOs or placeholders)
+- Prefer editing existing files over creating new ones
+- Use the project's established error handling patterns
+</development_workflow>
+
+<communication>
+- Be concise and direct. Responses appear in a chat panel.
+- Focus on practical solutions over theoretical discussion.
+- When unable to complete a request, explain the limitation briefly and
+  provide alternatives.
+- Use active language: "Analyzing...", "Searching..." instead of "Let me..."
+</communication>
+</system-reminder>`;
+
 // src/provider/duo-workflow-model.ts
 var sessions = /* @__PURE__ */ new Map();
 var UNKNOWN_USAGE = {
@@ -1442,6 +1362,8 @@ var DuoWorkflowModel = class {
   #sentToolCallIds = /* @__PURE__ */ new Set();
   #lastSentGoal = null;
   #stateSessionId;
+  #agentMode;
+  #agentModeReminder;
   constructor(modelId, client, cwd) {
     this.modelId = modelId;
     this.#client = client;
@@ -1481,6 +1403,8 @@ var DuoWorkflowModel = class {
       this.#multiCallGroups.clear();
       this.#sentToolCallIds.clear();
       this.#lastSentGoal = null;
+      this.#agentMode = void 0;
+      this.#agentModeReminder = void 0;
       this.#stateSessionId = sessionID;
     }
     const model = this;
@@ -1491,6 +1415,15 @@ var DuoWorkflowModel = class {
           const onAbort = () => session.abort();
           options.abortSignal?.addEventListener("abort", onAbort, { once: true });
           try {
+            if (!session.hasStarted) {
+              model.#sentToolCallIds.clear();
+              for (const r of toolResults) {
+                if (!model.#pendingToolRequests.has(r.toolCallId)) {
+                  model.#sentToolCallIds.add(r.toolCallId);
+                }
+              }
+              model.#lastSentGoal = null;
+            }
             const freshResults = toolResults.filter(
               (r) => !model.#sentToolCallIds.has(r.toolCallId)
             );
@@ -1530,7 +1463,41 @@ var DuoWorkflowModel = class {
             if (!sentToolResults && isNewGoal) {
               await session.ensureConnected(goal);
               if (!session.hasStarted) {
-                session.sendStartRequest(goal);
+                const extraContext = [];
+                extraContext.push(...buildSystemContext());
+                const systemPrompt = extractSystemPrompt(options.prompt);
+                if (systemPrompt) {
+                  extraContext.push({
+                    category: "agent_context",
+                    content: sanitizeSystemPrompt(systemPrompt),
+                    id: "agent_system_prompt",
+                    metadata: JSON.stringify({
+                      title: "Agent System Prompt",
+                      enabled: true,
+                      subType: "system_prompt"
+                    })
+                  });
+                }
+                const agentReminders = extractAgentReminders(options.prompt);
+                const modeReminder = detectLatestModeReminder(agentReminders);
+                if (modeReminder) {
+                  model.#agentMode = modeReminder.mode;
+                  model.#agentModeReminder = modeReminder.reminder;
+                }
+                const remindersForContext = buildReminderContext(agentReminders, model.#agentModeReminder);
+                if (remindersForContext.length > 0) {
+                  extraContext.push({
+                    category: "agent_context",
+                    content: sanitizeSystemPrompt(remindersForContext.join("\n\n")),
+                    id: "agent_reminders",
+                    metadata: JSON.stringify({
+                      title: "Agent Reminders",
+                      enabled: true,
+                      subType: "agent_reminders"
+                    })
+                  });
+                }
+                session.sendStartRequest(goal, extraContext);
               }
               model.#lastSentGoal = goal;
             }
@@ -1638,6 +1605,32 @@ var DuoWorkflowModel = class {
 function sessionKey(instanceUrl, modelId, sessionID) {
   return `${instanceUrl}::${modelId}::${sessionID}`;
 }
+function detectLatestModeReminder(reminders) {
+  let latest;
+  for (const reminder of reminders) {
+    const classification = classifyModeReminder(reminder);
+    if (classification === "other") continue;
+    latest = { mode: classification, reminder };
+  }
+  return latest;
+}
+function buildReminderContext(reminders, modeReminder) {
+  const nonModeReminders = reminders.filter(
+    (r) => classifyModeReminder(r) === "other"
+  );
+  if (!modeReminder) return nonModeReminders;
+  return [...nonModeReminders, modeReminder];
+}
+function classifyModeReminder(reminder) {
+  const text2 = reminder.toLowerCase();
+  if (text2.includes("operational mode has changed from build to plan")) return "plan";
+  if (text2.includes("operational mode has changed from plan to build")) return "build";
+  if (text2.includes("you are no longer in read-only mode")) return "build";
+  if (text2.includes("you are now in read-only mode")) return "plan";
+  if (text2.includes("you are in read-only mode")) return "plan";
+  if (text2.includes("you are permitted to make file changes")) return "build";
+  return "other";
+}
 
 // src/provider/index.ts
 function createFallbackProvider(input = {}) {

package/package.json

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