opencode-gitlab-duo-agentic 0.2.4 → 0.2.6

package/dist/index.js

@@ -400,7 +400,9 @@ import { randomUUID as randomUUID2 } from "crypto";
 var AsyncQueue = class {
   #values = [];
   #waiters = [];
+  #closed = false;
   push(value) {
+    if (this.#closed) return;
     const waiter = this.#waiters.shift();
     if (waiter) {
       waiter(value);
@@ -408,11 +410,20 @@ var AsyncQueue = class {
     }
     this.#values.push(value);
   }
+  /** Returns null when closed and no buffered values remain. */
   shift() {
     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));
   }
+  close() {
+    this.#closed = true;
+    for (const waiter of this.#waiters) {
+      waiter(null);
+    }
+    this.#waiters = [];
+  }
 };
 
 // src/workflow/checkpoint.ts
@@ -1021,8 +1032,9 @@ var WorkflowSession = class {
   #checkpoint = createCheckpointState();
   #toolsConfig;
   #toolExecutor;
-  /** Mutex: serialises concurrent calls to runTurn so only one runs at a time. */
-  #turnLock = Promise.resolve();
+  #socket;
+  #queue;
+  #startRequestSent = false;
   constructor(client, modelId, cwd) {
     this.#client = client;
     this.#tokenService = new WorkflowTokenService(client);
@@ -1032,7 +1044,6 @@ var WorkflowSession = class {
   }
   /**
    * 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;
@@ -1040,126 +1051,153 @@ var WorkflowSession = class {
   get workflowId() {
     return this.#workflowId;
   }
+  get hasStarted() {
+    return this.#startRequestSent;
+  }
   reset() {
     this.#workflowId = void 0;
     this.#checkpoint = createCheckpointState();
     this.#tokenService.clear();
-  }
-  async *runTurn(goal, abortSignal) {
-    await this.#turnLock;
-    let resolve2;
-    this.#turnLock = new Promise((r) => {
-      resolve2 = r;
-    });
-    const queue = new AsyncQueue();
+    this.#closeConnection();
+    this.#startRequestSent = false;
+  }
+  // ---------------------------------------------------------------------------
+  // Connection lifecycle (persistent)
+  // ---------------------------------------------------------------------------
+  async ensureConnected(goal) {
+    if (this.#socket && this.#queue) return;
+    if (!this.#workflowId) {
+      this.#workflowId = await this.#createWorkflow(goal);
+    }
+    await this.#tokenService.get(this.#rootNamespaceId);
+    this.#queue = new AsyncQueue();
+    const queue = this.#queue;
     const socket = new WorkflowWebSocketClient({
-      action: (action) => queue.push({ type: "action", action }),
-      error: (error) => queue.push({ type: "error", error }),
-      close: (code, reason) => queue.push({ type: "close", code, reason })
+      action: (action) => this.#handleAction(action, queue),
+      error: (error) => queue.push({ type: "error", message: error.message }),
+      close: (_code, _reason) => queue.close()
     });
-    const onAbort = () => {
-      socket.send({
-        stopWorkflow: {
-          reason: "ABORTED"
-        }
-      });
-      socket.close();
-    };
-    try {
-      if (abortSignal?.aborted) throw new Error("aborted");
-      if (!this.#workflowId) this.#workflowId = await this.#createWorkflow(goal);
-      const access = await this.#tokenService.get(this.#rootNamespaceId);
-      const url = buildWebSocketUrl(this.#client.instanceUrl, this.#modelId);
-      await socket.connect(url, {
-        authorization: `Bearer ${this.#client.token}`,
-        origin: new URL(this.#client.instanceUrl).origin,
-        "x-request-id": randomUUID2(),
-        "x-gitlab-client-type": "node-websocket"
-      });
-      abortSignal?.addEventListener("abort", onAbort, { once: true });
-      const mcpTools = this.#toolsConfig?.mcpTools ?? [];
-      const preapprovedTools = mcpTools.map((t) => t.name);
-      const sent = socket.send({
-        startRequest: {
-          workflowID: this.#workflowId,
-          clientVersion: WORKFLOW_CLIENT_VERSION,
-          workflowDefinition: WORKFLOW_DEFINITION,
-          goal,
-          workflowMetadata: JSON.stringify({
-            extended_logging: access?.workflow_metadata?.extended_logging ?? false
-          }),
-          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"
-          } : {}
-        }
-      });
-      if (!sent) throw new Error("failed to send workflow startRequest");
-      for (; ; ) {
-        const event = await queue.shift();
-        if (event.type === "error") throw event.error;
-        if (event.type === "close") {
-          if (event.code === 1e3 || event.code === 1006) return;
-          throw new Error(`workflow websocket closed abnormally (${event.code}): ${event.reason}`);
-        }
-        if (isCheckpointAction(event.action)) {
-          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;
-        }
-        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 url = buildWebSocketUrl(this.#client.instanceUrl, this.#modelId);
+    await socket.connect(url, {
+      authorization: `Bearer ${this.#client.token}`,
+      origin: new URL(this.#client.instanceUrl).origin,
+      "x-request-id": randomUUID2(),
+      "x-gitlab-client-type": "node-websocket"
+    });
+    this.#socket = socket;
+  }
+  // ---------------------------------------------------------------------------
+  // Messaging
+  // ---------------------------------------------------------------------------
+  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);
+    this.#socket.send({
+      startRequest: {
+        workflowID: this.#workflowId,
+        clientVersion: WORKFLOW_CLIENT_VERSION,
+        workflowDefinition: WORKFLOW_DEFINITION,
+        goal,
+        workflowMetadata: JSON.stringify({
+          extended_logging: false
+        }),
+        clientCapabilities: ["shell_command"],
+        mcpTools,
+        additional_context: additionalContext,
+        preapproved_tools: preapprovedTools,
+        ...this.#toolsConfig?.flowConfig ? {
+          flowConfig: this.#toolsConfig.flowConfig,
+          flowConfigSchemaVersion: this.#toolsConfig.flowConfigSchemaVersion ?? "v1"
+        } : {}
+      }
+    });
+    this.#startRequestSent = true;
+  }
+  /**
+   * 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"}`);
+    this.#socket.send({
+      actionResponse: {
+        requestID: requestId,
+        plainTextResponse: {
+          response: output,
+          error: error ?? ""
         }
-        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: result.response,
-              error: result.error ?? ""
-            }
-          }
+      }
+    });
+  }
+  /**
+   * Wait for the next event from the session.
+   * Returns null when the stream is closed (turn complete or connection lost).
+   */
+  async waitForEvent() {
+    if (!this.#queue) return null;
+    return this.#queue.shift();
+  }
+  /**
+   * Send an abort signal to DWS and close the connection.
+   */
+  abort() {
+    this.#socket?.send({ stopWorkflow: { reason: "ABORTED" } });
+    this.#closeConnection();
+  }
+  // ---------------------------------------------------------------------------
+  // Private: action handling
+  // ---------------------------------------------------------------------------
+  #handleAction(action, queue) {
+    if (isCheckpointAction(action)) {
+      const ckpt = action.newCheckpoint.checkpoint;
+      const deltas = extractAgentTextDeltas(ckpt, this.#checkpoint);
+      for (const delta of deltas) {
+        queue.push({ 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}`);
+        queue.push({
+          type: "tool-request",
+          requestId: req.requestId,
+          toolName: req.toolName,
+          args: req.args
         });
       }
-    } finally {
-      abortSignal?.removeEventListener("abort", onAbort);
-      socket.close();
-      resolve2();
+      if (isTurnComplete(action.newCheckpoint.status)) {
+        queue.close();
+        this.#closeConnection();
+      }
+      return;
+    }
+    if (action.requestID) {
+      console.error(`[duo-workflow] ws tool action: keys=${JSON.stringify(Object.keys(action).filter((k) => k !== "requestID"))}`);
+      this.#executeStandaloneAction(action);
     }
   }
+  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
+  // ---------------------------------------------------------------------------
+  #closeConnection() {
+    this.#socket?.close();
+    this.#socket = void 0;
+    this.#queue = void 0;
+    this.#startRequestSent = false;
+  }
   async #createWorkflow(goal) {
     await this.#loadProjectContext();
     const body = {
@@ -1167,9 +1205,7 @@ var WorkflowSession = class {
       workflow_definition: WORKFLOW_DEFINITION,
       environment: WORKFLOW_ENVIRONMENT,
       allow_agent_to_request_user: true,
-      ...this.#projectPath ? {
-        project_id: this.#projectPath
-      } : {}
+      ...this.#projectPath ? { project_id: this.#projectPath } : {}
     };
     const created = await post(this.#client, "ai/duo_workflows/workflows", body);
     if (created.id === void 0 || created.id === null) {
@@ -1220,6 +1256,220 @@ function stripSystemReminders(value) {
   }).trim();
 }
 
+// src/provider/prompt-utils.ts
+function extractToolResults(prompt) {
+  if (!Array.isArray(prompt)) return [];
+  const results = [];
+  for (const message of prompt) {
+    const content = message.content;
+    if (!Array.isArray(content)) continue;
+    for (const part of content) {
+      const p = part;
+      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;
+  if (isPlainObject(outputField) && "type" in outputField) {
+    const outputType = String(outputField.type);
+    const outputValue = outputField.value;
+    if (outputType === "text" || outputType === "json") {
+      return { output: typeof outputValue === "string" ? outputValue : JSON.stringify(outputValue ?? "") };
+    }
+    if (outputType === "error-text" || outputType === "error-json") {
+      return { output: "", error: typeof outputValue === "string" ? outputValue : JSON.stringify(outputValue ?? "") };
+    }
+    if (outputType === "content" && Array.isArray(outputValue)) {
+      const text2 = outputValue.filter((v) => v.type === "text").map((v) => String(v.text ?? "")).join("\n");
+      return { output: text2 };
+    }
+  }
+  if (outputField !== void 0) {
+    return { output: typeof outputField === "string" ? outputField : JSON.stringify(outputField) };
+  }
+  if (resultField !== void 0) {
+    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);
+}
+
+// src/provider/tool-mapping.ts
+function mapDuoToolRequest(toolName, args) {
+  switch (toolName) {
+    case "list_dir": {
+      const directory = asString3(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);
+      if (!filePath) return { toolName, args };
+      const mapped = { filePath };
+      if (typeof args.offset === "number") mapped.offset = args.offset;
+      if (typeof args.limit === "number") mapped.limit = args.limit;
+      return { toolName: "read", args: mapped };
+    }
+    case "read_files": {
+      const filePaths = asStringArray2(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);
+      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);
+      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);
+      if (!pattern) return { toolName, args };
+      return { toolName: "glob", args: { pattern } };
+    }
+    case "grep": {
+      const pattern = asString3(args.pattern);
+      if (!pattern) return { toolName, args };
+      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 };
+      if (searchDir) mapped.path = searchDir;
+      return { toolName: "grep", args: mapped };
+    }
+    case "mkdir": {
+      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 = asString3(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);
+      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);
+      if (!command) return { toolName, args };
+      return { toolName: "bash", args: { command, description: "Run command", workdir: "." } };
+    }
+    case "run_git_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(" ") : asString3(rawArgs);
+      const gitCmd = extraArgs ? `git ${shellQuote(command)} ${extraArgs}` : `git ${shellQuote(command)}`;
+      return { toolName: "bash", args: { command: gitCmd, description: "Run git command", workdir: "." } };
+    }
+    default:
+      return { toolName, args };
+  }
+}
+function asString3(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asStringArray2(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => typeof v === "string");
+}
+function shellQuote(s) {
+  if (/^[a-zA-Z0-9_\-./=:@]+$/.test(s)) return s;
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
 // src/provider/session-context.ts
 function readSessionID(options) {
   const providerBlock = readProviderBlock(options);
@@ -1240,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 = {
@@ -1255,6 +1584,14 @@ var DuoWorkflowModel = class {
   #client;
   #cwd;
   #toolsConfig;
+  // Tool tracking state (per model instance, reset on session change)
+  #pendingToolRequests = /* @__PURE__ */ new Map();
+  #multiCallGroups = /* @__PURE__ */ new Map();
+  #sentToolCallIds = /* @__PURE__ */ new Set();
+  #lastSentGoal = null;
+  #stateSessionId;
+  #agentMode;
+  #agentModeReminder;
   constructor(modelId, client, cwd) {
     this.modelId = modelId;
     this.#client = client;
@@ -1262,8 +1599,6 @@ var DuoWorkflowModel = class {
   }
   /**
    * 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;
@@ -1272,22 +1607,13 @@ var DuoWorkflowModel = class {
     }
   }
   async doGenerate(options) {
-    const sessionID = readSessionID(options);
-    if (!sessionID) throw new Error("missing workflow session ID");
-    const goal = extractGoal(options.prompt);
-    if (!goal) throw new Error("missing user message content");
-    const session = this.#resolveSession(sessionID);
-    const chunks = [];
-    for await (const item of session.runTurn(goal, options.abortSignal)) {
-      if (item.type === "text-delta") chunks.push(item.value);
+    let text2 = "";
+    const { stream } = await this.doStream(options);
+    for await (const part of stream) {
+      if (part.type === "text-delta") text2 += part.delta;
     }
     return {
-      content: [
-        {
-          type: "text",
-          text: chunks.join("")
-        }
-      ],
+      content: [{ type: "text", text: text2 }],
       finishReason: "stop",
       usage: UNKNOWN_USAGE,
       warnings: []
@@ -1297,57 +1623,188 @@ var DuoWorkflowModel = class {
     const sessionID = readSessionID(options);
     if (!sessionID) throw new Error("missing workflow session ID");
     const goal = extractGoal(options.prompt);
-    if (!goal) throw new Error("missing user message content");
+    const toolResults = extractToolResults(options.prompt);
     const session = this.#resolveSession(sessionID);
     const textId = randomUUID3();
+    if (sessionID !== this.#stateSessionId) {
+      this.#pendingToolRequests.clear();
+      this.#multiCallGroups.clear();
+      this.#sentToolCallIds.clear();
+      this.#lastSentGoal = null;
+      this.#agentMode = void 0;
+      this.#agentModeReminder = void 0;
+      this.#stateSessionId = sessionID;
+    }
+    const model = this;
     return {
       stream: new ReadableStream({
         start: async (controller) => {
-          controller.enqueue({
-            type: "stream-start",
-            warnings: []
-          });
-          let hasText = false;
+          controller.enqueue({ type: "stream-start", warnings: [] });
+          const onAbort = () => session.abort();
+          options.abortSignal?.addEventListener("abort", onAbort, { once: true });
           try {
-            for await (const item of session.runTurn(goal, options.abortSignal)) {
-              if (item.type !== "text-delta") continue;
-              if (!item.value) continue;
-              if (!hasText) {
-                hasText = true;
+            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)
+            );
+            let sentToolResults = false;
+            for (const result of freshResults) {
+              const hashIdx = result.toolCallId.indexOf("#");
+              if (hashIdx !== -1) {
+                const originalId = result.toolCallId.substring(0, hashIdx);
+                const group = model.#multiCallGroups.get(originalId);
+                if (!group) {
+                  model.#sentToolCallIds.add(result.toolCallId);
+                  continue;
+                }
+                group.collected.set(result.toolCallId, result.error ?? result.output);
+                model.#sentToolCallIds.add(result.toolCallId);
+                model.#pendingToolRequests.delete(result.toolCallId);
+                if (group.collected.size === group.subIds.length) {
+                  const aggregated = group.subIds.map((id) => group.collected.get(id) ?? "").join("\n");
+                  session.sendToolResult(originalId, aggregated);
+                  model.#multiCallGroups.delete(originalId);
+                  model.#pendingToolRequests.delete(originalId);
+                  sentToolResults = true;
+                }
+                continue;
+              }
+              const pending = model.#pendingToolRequests.get(result.toolCallId);
+              if (!pending) {
+                model.#sentToolCallIds.add(result.toolCallId);
+                continue;
+              }
+              session.sendToolResult(result.toolCallId, result.output, result.error);
+              sentToolResults = true;
+              model.#sentToolCallIds.add(result.toolCallId);
+              model.#pendingToolRequests.delete(result.toolCallId);
+            }
+            const isNewGoal = goal && goal !== model.#lastSentGoal;
+            if (!sentToolResults && isNewGoal) {
+              await session.ensureConnected(goal);
+              if (!session.hasStarted) {
+                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;
+            }
+            let hasText = false;
+            while (true) {
+              const event = await session.waitForEvent();
+              if (!event) break;
+              if (event.type === "text-delta") {
+                if (!event.value) continue;
+                if (!hasText) {
+                  hasText = true;
+                  controller.enqueue({ type: "text-start", id: textId });
+                }
+                controller.enqueue({ type: "text-delta", id: textId, delta: event.value });
+                continue;
+              }
+              if (event.type === "tool-request") {
+                let mapped;
+                try {
+                  mapped = mapDuoToolRequest(event.toolName, event.args);
+                } catch {
+                  continue;
+                }
+                if (hasText) {
+                  controller.enqueue({ type: "text-end", id: textId });
+                }
+                if (Array.isArray(mapped)) {
+                  const subIds = mapped.map((_, i) => `${event.requestId}#${i}`);
+                  model.#multiCallGroups.set(event.requestId, {
+                    subIds,
+                    collected: /* @__PURE__ */ new Map()
+                  });
+                  model.#pendingToolRequests.set(event.requestId, {});
+                  for (const subId of subIds) {
+                    model.#pendingToolRequests.set(subId, {});
+                  }
+                  for (let i = 0; i < mapped.length; i++) {
+                    controller.enqueue({
+                      type: "tool-call",
+                      toolCallId: subIds[i],
+                      toolName: mapped[i].toolName,
+                      input: JSON.stringify(mapped[i].args)
+                    });
+                  }
+                } else {
+                  model.#pendingToolRequests.set(event.requestId, {});
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: event.requestId,
+                    toolName: mapped.toolName,
+                    input: JSON.stringify(mapped.args)
+                  });
+                }
                 controller.enqueue({
-                  type: "text-start",
-                  id: textId
+                  type: "finish",
+                  finishReason: "tool-calls",
+                  usage: UNKNOWN_USAGE
                 });
+                controller.close();
+                return;
+              }
+              if (event.type === "error") {
+                controller.enqueue({ type: "error", error: new Error(event.message) });
+                controller.enqueue({ type: "finish", finishReason: "error", usage: UNKNOWN_USAGE });
+                controller.close();
+                return;
               }
-              controller.enqueue({
-                type: "text-delta",
-                id: textId,
-                delta: item.value
-              });
             }
             if (hasText) {
-              controller.enqueue({
-                type: "text-end",
-                id: textId
-              });
+              controller.enqueue({ type: "text-end", id: textId });
             }
-            controller.enqueue({
-              type: "finish",
-              finishReason: "stop",
-              usage: UNKNOWN_USAGE
-            });
+            controller.enqueue({ type: "finish", finishReason: "stop", usage: UNKNOWN_USAGE });
             controller.close();
           } catch (error) {
-            controller.enqueue({
-              type: "error",
-              error
-            });
-            controller.enqueue({
-              type: "finish",
-              finishReason: "error",
-              usage: UNKNOWN_USAGE
-            });
+            controller.enqueue({ type: "error", error });
+            controller.enqueue({ type: "finish", finishReason: "error", usage: UNKNOWN_USAGE });
             controller.close();
+          } finally {
+            options.abortSignal?.removeEventListener("abort", onAbort);
           }
         }
       }),
@@ -1376,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.4",
+  "version": "0.2.6",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",