opencode-gitlab-duo-agentic 0.2.5 → 0.2.6

package/dist/index.js

@@ -1089,7 +1089,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 +1104,7 @@ var WorkflowSession = class {
         }),
         clientCapabilities: ["shell_command"],
         mcpTools,
-        additional_context: [],
+        additional_context: additionalContext,
         preapproved_tools: preapprovedTools,
         ...this.#toolsConfig?.flowConfig ? {
           flowConfig: this.#toolsConfig.flowConfig,
@@ -1265,16 +1265,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 ?? asString2(p.error) ?? asString2(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 ?? "");
+        results.push({ toolCallId, toolName, output: "", error });
+      }
     }
   }
   return results;
 }
+function asString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
 function parseToolResultOutput(part) {
   const outputField = part.output;
   const resultField = part.result;
@@ -1296,10 +1308,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) ? asString2(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);
 }
@@ -1308,14 +1377,14 @@ function isPlainObject(value) {
 function mapDuoToolRequest(toolName, args) {
   switch (toolName) {
     case "list_dir": {
-      const directory = asString2(args.directory) ?? ".";
+      const directory = asString3(args.directory) ?? ".";
       return {
         toolName: "bash",
         args: { command: `ls -la ${shellQuote(directory)}`, description: "List directory contents", workdir: "." }
       };
     }
     case "read_file": {
-      const filePath = asString2(args.file_path) ?? asString2(args.filepath) ?? asString2(args.filePath) ?? asString2(args.path);
+      const filePath = asString3(args.file_path) ?? asString3(args.filepath) ?? asString3(args.filePath) ?? asString3(args.path);
       if (!filePath) return { toolName, args };
       const mapped = { filePath };
       if (typeof args.offset === "number") mapped.offset = args.offset;
@@ -1328,27 +1397,27 @@ function mapDuoToolRequest(toolName, args) {
       return filePaths.map((fp) => ({ toolName: "read", args: { filePath: fp } }));
     }
     case "create_file_with_contents": {
-      const filePath = asString2(args.file_path);
-      const content = asString2(args.contents);
+      const filePath = asString3(args.file_path);
+      const content = asString3(args.contents);
       if (!filePath || content === void 0) return { toolName, args };
       return { toolName: "write", args: { filePath, content } };
     }
     case "edit_file": {
-      const filePath = asString2(args.file_path);
-      const oldString = asString2(args.old_str);
-      const newString = asString2(args.new_str);
+      const filePath = asString3(args.file_path);
+      const oldString = asString3(args.old_str);
+      const newString = asString3(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 = asString2(args.name_pattern);
+      const pattern = asString3(args.name_pattern);
       if (!pattern) return { toolName, args };
       return { toolName: "glob", args: { pattern } };
     }
     case "grep": {
-      const pattern = asString2(args.pattern);
+      const pattern = asString3(args.pattern);
       if (!pattern) return { toolName, args };
-      const searchDir = asString2(args.search_directory);
+      const searchDir = asString3(args.search_directory);
       const caseInsensitive = Boolean(args.case_insensitive);
       const normalizedPattern = caseInsensitive && !pattern.startsWith("(?i)") ? `(?i)${pattern}` : pattern;
       const mapped = { pattern: normalizedPattern };
@@ -1356,32 +1425,32 @@ function mapDuoToolRequest(toolName, args) {
       return { toolName: "grep", args: mapped };
     }
     case "mkdir": {
-      const directory = asString2(args.directory_path);
+      const directory = asString3(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 = asString2(args.command);
+      const command = asString3(args.command);
       if (!command) return { toolName, args };
       return { toolName: "bash", args: { command, description: "Run shell command", workdir: "." } };
     }
     case "run_command": {
-      const program = asString2(args.program);
+      const program = asString3(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 = asString2(args.command);
+      const command = asString3(args.command);
       if (!command) return { toolName, args };
       return { toolName: "bash", args: { command, description: "Run command", workdir: "." } };
     }
     case "run_git_command": {
-      const command = asString2(args.command);
+      const command = asString3(args.command);
       if (!command) return { toolName, args };
       const rawArgs = args.args;
-      const extraArgs = Array.isArray(rawArgs) ? rawArgs.map((v) => shellQuote(String(v))).join(" ") : asString2(rawArgs);
+      const extraArgs = Array.isArray(rawArgs) ? rawArgs.map((v) => shellQuote(String(v))).join(" ") : asString3(rawArgs);
       const gitCmd = extraArgs ? `git ${shellQuote(command)} ${extraArgs}` : `git ${shellQuote(command)}`;
       return { toolName: "bash", args: { command: gitCmd, description: "Run git command", workdir: "." } };
     }
@@ -1389,7 +1458,7 @@ function mapDuoToolRequest(toolName, args) {
       return { toolName, args };
   }
 }
-function asString2(value) {
+function asString3(value) {
   return typeof value === "string" ? value : void 0;
 }
 function asStringArray2(value) {
@@ -1421,6 +1490,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 +1590,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 +1631,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 +1643,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 +1691,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 +1833,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.6",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",