opencode-gitlab-duo-agentic 0.2.2 → 0.2.5

package/dist/index.js

@@ -391,16 +391,18 @@ function isGitLabProvider(model) {
 import { NoSuchModelError } from "@ai-sdk/provider";
 
 // src/provider/duo-workflow-model.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/workflow/session.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/utils/async-queue.ts
 var AsyncQueue = class {
   #values = [];
   #waiters = [];
+  #closed = false;
   push(value) {
+    if (this.#closed) return;
     const waiter = this.#waiters.shift();
     if (waiter) {
       waiter(value);
@@ -408,17 +410,28 @@ 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
+import { randomUUID } from "crypto";
 function createCheckpointState() {
   return {
-    uiChatLog: []
+    uiChatLog: [],
+    processedRequestIndices: /* @__PURE__ */ new Set()
   };
 }
 function extractAgentTextDeltas(checkpoint, state) {
@@ -443,6 +456,23 @@ function extractAgentTextDeltas(checkpoint, state) {
   state.uiChatLog = next;
   return out;
 }
+function extractToolRequests(checkpoint, state) {
+  const next = parseCheckpoint(checkpoint);
+  const requests = [];
+  for (let i = 0; i < next.length; i++) {
+    const item = next[i];
+    if (item.message_type !== "request") continue;
+    if (!item.tool_info) continue;
+    if (state.processedRequestIndices.has(i)) continue;
+    state.processedRequestIndices.add(i);
+    requests.push({
+      requestId: item.correlation_id ?? randomUUID(),
+      toolName: item.tool_info.name,
+      args: item.tool_info.args ?? {}
+    });
+  }
+  return requests;
+}
 function parseCheckpoint(raw) {
   if (!raw) return [];
   try {
@@ -624,6 +654,16 @@ function decodeSocketMessage(data) {
 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;
@@ -631,9 +671,104 @@ var ToolExecutor = class {
     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}` };
+        }
+      }
+    } catch (err) {
+      console.error(`[tool-executor] executeDuoTool error:`, err);
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
   /**
    * Route a Duo WorkflowToolAction to the appropriate local handler.
-   * This is the main bridge entry point.
+   * This handles standalone WebSocket actions (non-checkpoint path).
    */
   async executeAction(action) {
     try {
@@ -695,8 +830,11 @@ var ToolExecutor = class {
       if (action.runHTTPRequest) {
         return this.#httpRequest(action.runHTTPRequest);
       }
-      return { response: "", error: "Unknown tool action" };
+      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) };
     }
   }
@@ -894,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);
@@ -905,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;
@@ -913,103 +1051,152 @@ 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": randomUUID(),
-        "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: [],
-          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 deltas = extractAgentTextDeltas(event.action.newCheckpoint.checkpoint, this.#checkpoint);
-          for (const delta of deltas) {
-            yield {
-              type: "text-delta",
-              value: delta
-            };
-          }
-          if (isTurnComplete(event.action.newCheckpoint.status)) {
-            socket.close();
-          }
-          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) {
+    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: [],
+        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 ?? ""
         }
-        if (!event.action.requestID) continue;
-        const result = await this.#toolExecutor.executeAction(event.action);
-        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();
@@ -1018,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) {
@@ -1071,6 +1256,151 @@ 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") 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 });
+    }
+  }
+  return results;
+}
+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) {
+    return { output: typeof resultField === "string" ? resultField : JSON.stringify(resultField) };
+  }
+  return { output: "" };
+}
+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 = asString2(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);
+      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 = asString2(args.file_path);
+      const content = asString2(args.contents);
+      if (!filePath || content === void 0) return { toolName, args };
+      return { toolName: "write", args: { filePath, content } };
+    }
+    case "edit_file": {
+      const filePath = asString2(args.file_path);
+      const oldString = asString2(args.old_str);
+      const newString = asString2(args.new_str);
+      if (!filePath || oldString === void 0 || newString === void 0) return { toolName, args };
+      return { toolName: "edit", args: { filePath, oldString, newString } };
+    }
+    case "find_files": {
+      const pattern = asString2(args.name_pattern);
+      if (!pattern) return { toolName, args };
+      return { toolName: "glob", args: { pattern } };
+    }
+    case "grep": {
+      const pattern = asString2(args.pattern);
+      if (!pattern) return { toolName, args };
+      const searchDir = asString2(args.search_directory);
+      const caseInsensitive = Boolean(args.case_insensitive);
+      const normalizedPattern = caseInsensitive && !pattern.startsWith("(?i)") ? `(?i)${pattern}` : pattern;
+      const mapped = { pattern: normalizedPattern };
+      if (searchDir) mapped.path = searchDir;
+      return { toolName: "grep", args: mapped };
+    }
+    case "mkdir": {
+      const directory = asString2(args.directory_path);
+      if (!directory) return { toolName, args };
+      return { toolName: "bash", args: { command: `mkdir -p ${shellQuote(directory)}`, description: "Create directory", workdir: "." } };
+    }
+    case "shell_command": {
+      const command = asString2(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);
+      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);
+      if (!command) return { toolName, args };
+      return { toolName: "bash", args: { command, description: "Run command", workdir: "." } };
+    }
+    case "run_git_command": {
+      const command = asString2(args.command);
+      if (!command) return { toolName, args };
+      const rawArgs = args.args;
+      const extraArgs = Array.isArray(rawArgs) ? rawArgs.map((v) => shellQuote(String(v))).join(" ") : asString2(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 asString2(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);
@@ -1106,6 +1436,12 @@ 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;
   constructor(modelId, client, cwd) {
     this.modelId = modelId;
     this.#client = client;
@@ -1113,8 +1449,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;
@@ -1123,22 +1457,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: []
@@ -1148,57 +1473,143 @@ 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 = randomUUID2();
+    const textId = randomUUID3();
+    if (sessionID !== this.#stateSessionId) {
+      this.#pendingToolRequests.clear();
+      this.#multiCallGroups.clear();
+      this.#sentToolCallIds.clear();
+      this.#lastSentGoal = null;
+      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;
+            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) {
+                session.sendStartRequest(goal);
+              }
+              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);
           }
         }
       }),

package/package.json

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