opencode-gitlab-duo-agentic 0.1.23 → 0.2.1

package/dist/index.js

@@ -17,6 +17,7 @@ import crypto from "crypto";
 import fs2 from "fs/promises";
 import os from "os";
 import path2 from "path";
+import { z } from "zod";
 
 // src/gitlab/client.ts
 var GitLabApiError = class extends Error {
@@ -135,8 +136,8 @@ async function resolveRootNamespaceId(client, namespaceId) {
 }
 async function readGitConfig(cwd) {
   const gitPath = path.join(cwd, ".git");
-  const stat = await fs.stat(gitPath);
-  if (stat.isDirectory()) {
+  const stat2 = await fs.stat(gitPath);
+  if (stat2.isDirectory()) {
     return fs.readFile(path.join(gitPath, "config"), "utf8");
   }
   const content = await fs.readFile(gitPath, "utf8");
@@ -190,6 +191,16 @@ function normalizeProjectPath(remotePath, instanceBasePath) {
 }
 
 // src/gitlab/models.ts
+var CachePayloadSchema = z.object({
+  cachedAt: z.string(),
+  instanceUrl: z.string(),
+  models: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string()
+    })
+  ).min(1)
+});
 var QUERY = `query lsp_aiChatAvailableModels($rootNamespaceId: GroupID!) {
   aiChatAvailableModels(rootNamespaceId: $rootNamespaceId) {
     defaultModel { name ref }
@@ -251,8 +262,7 @@ function isStale(payload) {
 async function readCache(cachePath) {
   try {
     const raw = await fs2.readFile(cachePath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.models?.length) return null;
+    const parsed = CachePayloadSchema.parse(JSON.parse(raw));
     return parsed;
   } catch {
     return null;
@@ -286,13 +296,28 @@ function normalizeInstanceUrl(value) {
   }
 }
 
+// src/gitlab/resolve-credentials.ts
+function resolveCredentials(options = {}) {
+  const instanceUrl = normalizeInstanceUrl(options.instanceUrl ?? envInstanceUrl());
+  const token = firstNonEmptyString(options.apiKey, options.token) ?? envToken() ?? "";
+  return { instanceUrl, token };
+}
+function envToken() {
+  return process.env.GITLAB_TOKEN ?? process.env.GITLAB_OAUTH_TOKEN;
+}
+function firstNonEmptyString(...values) {
+  for (const v of values) {
+    if (typeof v === "string" && v.trim().length > 0) return v.trim();
+  }
+  return void 0;
+}
+
 // src/plugin/config.ts
 async function applyRuntimeConfig(config, directory) {
   config.provider ??= {};
   const current = config.provider[PROVIDER_ID] ?? {};
   const options = current.options ?? {};
-  const instanceUrl = normalizeInstanceUrl(options.instanceUrl ?? envInstanceUrl());
-  const token = (typeof options.apiKey === "string" ? options.apiKey : void 0) ?? process.env.GITLAB_TOKEN ?? process.env.GITLAB_OAUTH_TOKEN ?? "";
+  const { instanceUrl, token } = resolveCredentials(options);
   const available = await loadAvailableModels(instanceUrl, token, directory);
   const modelIds = available.map((m) => m.id);
   const models = toModelsConfig(available);
@@ -318,8 +343,236 @@ function toModelsConfig(available) {
   return out;
 }
 
+// src/workflow/opencode-tools.ts
+var SUPPORTED_TOOLS = /* @__PURE__ */ new Set([
+  "bash",
+  "read",
+  "edit",
+  "write",
+  "glob",
+  "grep"
+]);
+async function fetchOpencodeTools(client, provider, model) {
+  try {
+    const response = await client.tool.list({ provider, model });
+    const tools = response.data ?? [];
+    return tools.filter((t) => SUPPORTED_TOOLS.has(t.id)).map((t) => ({
+      name: t.id,
+      description: t.description,
+      inputSchema: typeof t.parameters === "string" ? t.parameters : JSON.stringify(t.parameters)
+    }));
+  } catch {
+    return [];
+  }
+}
+function buildFallbackTools() {
+  return [
+    {
+      name: "bash",
+      description: "Execute a shell command. Use the `command` parameter for the command to run, `description` for a short summary, optional `timeout` in milliseconds, and optional `workdir` to set the working directory.",
+      inputSchema: JSON.stringify({
+        type: "object",
+        properties: {
+          command: { type: "string", description: "The command to execute" },
+          description: { type: "string", description: "Clear, concise description of what this command does in 5-10 words" },
+          timeout: { type: "number", description: "Optional timeout in milliseconds" },
+          workdir: { type: "string", description: "The working directory to run the command in" }
+        },
+        required: ["command", "description"]
+      })
+    },
+    {
+      name: "read",
+      description: "Read a file or directory from the local filesystem. Returns content with line numbers prefixed. Supports offset and limit for pagination. Can read images and PDFs as attachments.",
+      inputSchema: JSON.stringify({
+        type: "object",
+        properties: {
+          filePath: { type: "string", description: "The absolute path to the file or directory to read" },
+          offset: { type: "number", description: "The line number to start reading from (1-indexed)" },
+          limit: { type: "number", description: "The maximum number of lines to read (defaults to 2000)" }
+        },
+        required: ["filePath"]
+      })
+    },
+    {
+      name: "edit",
+      description: "Performs exact string replacements in files. The oldString must match the file contents exactly. Provide surrounding context to make the match unique.",
+      inputSchema: JSON.stringify({
+        type: "object",
+        properties: {
+          filePath: { type: "string", description: "The absolute path to the file to modify" },
+          oldString: { type: "string", description: "The text to replace" },
+          newString: { type: "string", description: "The text to replace it with" },
+          replaceAll: { type: "boolean", description: "Replace all occurrences (default false)" }
+        },
+        required: ["filePath", "oldString", "newString"]
+      })
+    },
+    {
+      name: "write",
+      description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Parent directories are created automatically.",
+      inputSchema: JSON.stringify({
+        type: "object",
+        properties: {
+          filePath: { type: "string", description: "The absolute path to the file to write" },
+          content: { type: "string", description: "The content to write to the file" }
+        },
+        required: ["filePath", "content"]
+      })
+    },
+    {
+      name: "glob",
+      description: "Fast file pattern matching. Supports glob patterns like '**/*.js' or 'src/**/*.ts'. Returns matching file paths sorted by modification time.",
+      inputSchema: JSON.stringify({
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "The glob pattern to match files against" },
+          path: { type: "string", description: "The directory to search in" }
+        },
+        required: ["pattern"]
+      })
+    },
+    {
+      name: "grep",
+      description: "Fast content search using regular expressions. Returns file paths and line numbers with matches. Supports filtering files by pattern with the include parameter.",
+      inputSchema: JSON.stringify({
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "The regex pattern to search for in file contents" },
+          path: { type: "string", description: "The directory to search in" },
+          include: { type: "string", description: "File pattern to include in the search (e.g. '*.js', '*.{ts,tsx}')" }
+        },
+        required: ["pattern"]
+      })
+    }
+  ];
+}
+
+// src/workflow/flow-config.ts
+function buildFlowConfig(systemPrompt) {
+  return {
+    version: "v1",
+    environment: "chat-partial",
+    components: [
+      {
+        name: "opencode_agent",
+        type: "AgentComponent",
+        // Empty toolset: we rely entirely on MCP tools (OpenCode tools)
+        // registered via the mcpTools field in startRequest
+        toolset: []
+      }
+    ],
+    prompts: [
+      {
+        name: "opencode_prompt",
+        prompt_id: "opencode_prompt",
+        model: {
+          params: {
+            model_class_provider: "anthropic",
+            max_tokens: 32768
+          }
+        },
+        unit_primitives: ["duo_chat"],
+        prompt_template: {
+          system: systemPrompt,
+          user: "{{goal}}",
+          placeholder: "history"
+        }
+      }
+    ]
+  };
+}
+var OPENCODE_SYSTEM_PROMPT = `You are OpenCode, an AI coding assistant integrated with GitLab Duo.
+
+<core_mission>
+Your primary role is collaborative programming - working alongside the user to accomplish coding objectives using the tools available to you.
+</core_mission>
+
+<communication_guidelines>
+- Provide clear and concise responses. Brevity and clarity are critical.
+- Focus on clean, practical solutions that help users make progress.
+- Keep responses brief and to the point. One-word answers are fine when they suffice.
+- Use active, present-tense language: 'Analyzing...', 'Processing...' instead of 'Let me...', 'I will...'
+- When unable to complete requests, explain the limitation concisely and provide alternatives.
+- When users correct you, acknowledge briefly and apply the correction immediately.
+</communication_guidelines>
+
+<tool_usage>
+You have access to file system and shell tools. Use them effectively:
+
+- Use the 'read' tool to read files before editing them.
+- Use the 'edit' tool for precise string replacements in existing files.
+- Use the 'write' tool to create new files or overwrite existing ones.
+- Use the 'glob' tool to find files by name patterns.
+- Use the 'grep' tool to search file contents with regex.
+- Use the 'bash' tool for shell commands (git, npm, docker, tests, builds, etc.).
+
+Tool orchestration:
+- Execute multiple independent tool operations in parallel when possible.
+- Read files before modifying them to understand context.
+- Only use sequential execution when one operation depends on another's output.
+- Plan your information needs upfront and execute searches together.
+</tool_usage>
+
+<code_analysis>
+Before writing any code:
+1. Read existing files to understand context and preserve important logic.
+2. Check dependencies exist before importing.
+3. Match existing patterns: import style, naming conventions, component structure, error handling.
+</code_analysis>
+
+<code_standards>
+- Write high-quality, general purpose solutions that work for all valid inputs.
+- Make code immediately executable. No placeholders like "TODO: implement this".
+- Match existing patterns in the codebase.
+- Follow the project's established error handling approach.
+- Verify changes work as expected before completing the task.
+</code_standards>
+
+<file_guidelines>
+- ALWAYS prefer editing existing files over creating new ones.
+- NEVER create documentation files unless explicitly requested.
+- Use extended thinking for complex tasks rather than creating temporary files.
+</file_guidelines>
+
+<git_guidelines>
+When working with git:
+- Only create commits when explicitly requested by the user.
+- NEVER run destructive git commands (push --force, hard reset) unless explicitly requested.
+- NEVER skip hooks unless explicitly requested.
+- Draft concise commit messages that focus on the "why" rather than the "what".
+- Do not push to remote unless explicitly asked.
+</git_guidelines>`;
+
+// src/workflow/tools-config-store.ts
+var stored;
+function setToolsConfig(config) {
+  stored = config;
+}
+function getToolsConfig() {
+  return stored;
+}
+
 // src/plugin/hooks.ts
+async function initializeToolsConfig(input) {
+  let mcpTools = await fetchOpencodeTools(
+    input.client,
+    "gitlab",
+    "duo-chat-sonnet-4-5"
+  );
+  if (mcpTools.length === 0) {
+    mcpTools = buildFallbackTools();
+  }
+  const flowConfig = buildFlowConfig(OPENCODE_SYSTEM_PROMPT);
+  setToolsConfig({
+    mcpTools,
+    flowConfig,
+    flowConfigSchemaVersion: "v1"
+  });
+}
 async function createPluginHooks(input) {
+  initializeToolsConfig(input).catch(() => {
+  });
   return {
     config: async (config) => applyRuntimeConfig(config, input.directory),
     "chat.message": async ({ sessionID }, { parts }) => {
@@ -354,7 +607,8 @@ async function createPluginHooks(input) {
 }
 var UTILITY_AGENTS = /* @__PURE__ */ new Set(["title", "compaction"]);
 function isUtilityAgent(agent) {
-  return UTILITY_AGENTS.has(agent.name);
+  const name = typeof agent === "string" ? agent : agent.name;
+  return UTILITY_AGENTS.has(name);
 }
 function isGitLabProvider(model) {
   if (model.api?.npm === "opencode-gitlab-duo-agentic") return true;
@@ -371,6 +625,25 @@ import { randomUUID as randomUUID2 } from "crypto";
 // src/workflow/session.ts
 import { randomUUID } from "crypto";
 
+// src/utils/async-queue.ts
+var AsyncQueue = class {
+  #values = [];
+  #waiters = [];
+  push(value) {
+    const waiter = this.#waiters.shift();
+    if (waiter) {
+      waiter(value);
+      return;
+    }
+    this.#values.push(value);
+  }
+  shift() {
+    const value = this.#values.shift();
+    if (value !== void 0) return Promise.resolve(value);
+    return new Promise((resolve2) => this.#waiters.push(resolve2));
+  }
+};
+
 // src/workflow/checkpoint.ts
 function createCheckpointState() {
   return {
@@ -470,6 +743,23 @@ var WORKFLOW_STATUS = {
   PLAN_APPROVAL_REQUIRED: "PLAN_APPROVAL_REQUIRED",
   TOOL_CALL_APPROVAL_REQUIRED: "TOOL_CALL_APPROVAL_REQUIRED"
 };
+function isCheckpointAction(action) {
+  return "newCheckpoint" in action && action.newCheckpoint != null;
+}
+function isMcpToolAction(action) {
+  return "runMCPTool" in action && action.runMCPTool != null;
+}
+var TURN_COMPLETE_STATUSES = /* @__PURE__ */ new Set([
+  WORKFLOW_STATUS.INPUT_REQUIRED,
+  WORKFLOW_STATUS.FINISHED,
+  WORKFLOW_STATUS.FAILED,
+  WORKFLOW_STATUS.STOPPED,
+  WORKFLOW_STATUS.PLAN_APPROVAL_REQUIRED,
+  WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED
+]);
+function isTurnComplete(status) {
+  return TURN_COMPLETE_STATUSES.has(status);
+}
 
 // src/workflow/websocket-client.ts
 import WebSocket from "isomorphic-ws";
@@ -484,7 +774,7 @@ var WorkflowWebSocketClient = class {
   async connect(url, headers) {
     const socket = new WebSocket(url, { headers });
     this.#socket = socket;
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timeout = setTimeout(() => {
         cleanup();
         socket.close(1e3);
@@ -497,7 +787,7 @@ var WorkflowWebSocketClient = class {
       };
       const onOpen = () => {
         cleanup();
-        resolve();
+        resolve2();
       };
       const onError = (error) => {
         cleanup();
@@ -562,20 +852,164 @@ function decodeSocketMessage(data) {
   return void 0;
 }
 
+// src/workflow/tool-executor.ts
+import { readFile, readdir, writeFile, mkdir, stat } from "fs/promises";
+import { exec } from "child_process";
+import { resolve, dirname } from "path";
+var ToolExecutor = class {
+  #cwd;
+  constructor(cwd) {
+    this.#cwd = cwd;
+  }
+  async execute(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 tool: ${name}` };
+    }
+  }
+  async #bash(args) {
+    const cwd = args.workdir ? resolve(this.#cwd, args.workdir) : this.#cwd;
+    const timeout = args.timeout ?? 12e4;
+    return new Promise((resolve2) => {
+      exec(args.command, { cwd, timeout, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+        if (error) {
+          const output2 = [stdout, stderr].filter(Boolean).join("\n");
+          resolve2({ response: output2, error: error.message });
+          return;
+        }
+        const output = [stdout, stderr].filter(Boolean).join("\n");
+        resolve2({ response: output });
+      });
+    });
+  }
+  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") };
+      }
+      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 #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) };
+    }
+  }
+  async #write(args) {
+    try {
+      const filepath = resolve(this.#cwd, args.filePath);
+      await mkdir(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) };
+    }
+  }
+  async #glob(args) {
+    const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
+    return new Promise((resolve2) => {
+      const command = process.platform === "win32" ? `dir /s /b "${args.pattern}"` : `find . -path "./${args.pattern}" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -200`;
+      exec(command, { cwd, timeout: 3e4 }, (error, stdout) => {
+        if (error && !stdout) {
+          exec(`ls -1 ${args.pattern} 2>/dev/null | head -200`, { cwd, timeout: 3e4 }, (_err, out) => {
+            resolve2({ response: out.trim() || "No matches found" });
+          });
+          return;
+        }
+        const lines = stdout.trim().split("\n").filter(Boolean);
+        resolve2({ response: lines.length > 0 ? lines.join("\n") : "No matches found" });
+      });
+    });
+  }
+  async #grep(args) {
+    const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
+    return new Promise((resolve2) => {
+      const includeFlag = args.include ? `--glob '${args.include}'` : "";
+      const rgCommand = `rg --line-number --no-heading ${includeFlag} '${args.pattern.replace(/'/g, "'\\''")}' . 2>/dev/null | head -500`;
+      exec(rgCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (error, stdout) => {
+        if (stdout.trim()) {
+          resolve2({ response: stdout.trim() });
+          return;
+        }
+        const grepInclude = args.include ? `--include='${args.include}'` : "";
+        const grepCommand = `grep -rn ${grepInclude} '${args.pattern.replace(/'/g, "'\\''")}' . 2>/dev/null | head -500`;
+        exec(grepCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (_err, out) => {
+          resolve2({ response: out.trim() || "No matches found" });
+        });
+      });
+    });
+  }
+};
+
 // src/workflow/session.ts
 var WorkflowSession = class {
   #client;
   #tokenService;
   #modelId;
+  #cwd;
   #workflowId;
   #projectPath;
   #rootNamespaceId;
   #checkpoint = createCheckpointState();
-  #pending = Promise.resolve();
-  constructor(client, modelId) {
+  #toolsConfig;
+  #toolExecutor;
+  /** Mutex: serialises concurrent calls to runTurn so only one runs at a time. */
+  #turnLock = Promise.resolve();
+  constructor(client, modelId, cwd) {
     this.#client = client;
     this.#tokenService = new WorkflowTokenService(client);
     this.#modelId = modelId;
+    this.#cwd = cwd;
+    this.#toolExecutor = new ToolExecutor(cwd);
+  }
+  setToolsConfig(config) {
+    this.#toolsConfig = config;
   }
   get workflowId() {
     return this.#workflowId;
@@ -586,10 +1020,10 @@ var WorkflowSession = class {
     this.#tokenService.clear();
   }
   async *runTurn(goal, abortSignal) {
-    await this.#pending;
-    let resolve;
-    this.#pending = new Promise((r) => {
-      resolve = r;
+    await this.#turnLock;
+    let resolve2;
+    this.#turnLock = new Promise((r) => {
+      resolve2 = r;
     });
     const queue = new AsyncQueue();
     const socket = new WorkflowWebSocketClient({
@@ -617,6 +1051,8 @@ var WorkflowSession = class {
         "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,
@@ -627,9 +1063,13 @@ var WorkflowSession = class {
             extended_logging: access?.workflow_metadata?.extended_logging ?? false
           }),
           clientCapabilities: [],
-          mcpTools: [],
+          mcpTools,
           additional_context: [],
-          preapproved_tools: []
+          preapproved_tools: preapprovedTools,
+          ...this.#toolsConfig?.flowConfig ? {
+            flowConfig: this.#toolsConfig.flowConfig,
+            flowConfigSchemaVersion: this.#toolsConfig.flowConfigSchemaVersion ?? "v1"
+          } : {}
         }
       });
       if (!sent) throw new Error("failed to send workflow startRequest");
@@ -654,6 +1094,20 @@ var WorkflowSession = class {
           continue;
         }
         if (!event.action.requestID) continue;
+        if (isMcpToolAction(event.action)) {
+          const { name, args } = event.action.runMCPTool;
+          const result = await this.#toolExecutor.execute(name, args);
+          socket.send({
+            actionResponse: {
+              requestID: event.action.requestID,
+              plainTextResponse: {
+                response: result.response,
+                error: result.error ?? ""
+              }
+            }
+          });
+          continue;
+        }
         socket.send({
           actionResponse: {
             requestID: event.action.requestID,
@@ -667,7 +1121,7 @@ var WorkflowSession = class {
     } finally {
       abortSignal?.removeEventListener("abort", onAbort);
       socket.close();
-      resolve();
+      resolve2();
     }
   }
   async #createWorkflow(goal) {
@@ -690,7 +1144,7 @@ var WorkflowSession = class {
   }
   async #loadProjectContext() {
     if (this.#projectPath !== void 0) return;
-    const projectPath = await detectProjectPath(process.cwd(), this.#client.instanceUrl);
+    const projectPath = await detectProjectPath(this.#cwd, this.#client.instanceUrl);
     this.#projectPath = projectPath;
     if (!projectPath) return;
     try {
@@ -701,12 +1155,6 @@ var WorkflowSession = class {
     }
   }
 };
-function isCheckpointAction(action) {
-  return Boolean(action.newCheckpoint);
-}
-function isTurnComplete(status) {
-  return status === WORKFLOW_STATUS.INPUT_REQUIRED || status === WORKFLOW_STATUS.FINISHED || status === WORKFLOW_STATUS.FAILED || status === WORKFLOW_STATUS.STOPPED || status === WORKFLOW_STATUS.PLAN_APPROVAL_REQUIRED || status === WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED;
-}
 function buildWebSocketUrl(instanceUrl, modelId) {
   const base = new URL(instanceUrl.endsWith("/") ? instanceUrl : `${instanceUrl}/`);
   const url = new URL("api/v4/ai/duo_workflows/ws", base);
@@ -715,35 +1163,73 @@ function buildWebSocketUrl(instanceUrl, modelId) {
   if (modelId) url.searchParams.set("user_selected_model_identifier", modelId);
   return url.toString();
 }
-var AsyncQueue = class {
-  #values = [];
-  #waiters = [];
-  push(value) {
-    const waiter = this.#waiters.shift();
-    if (waiter) {
-      waiter(value);
-      return;
-    }
-    this.#values.push(value);
+
+// src/provider/prompt.ts
+var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+var WRAPPED_USER_RE = /^<system-reminder>\s*The user sent the following message:\s*\n([\s\S]*?)\n\s*Please address this message and continue with your tasks\.\s*<\/system-reminder>$/;
+function extractGoal(prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const message = prompt[i];
+    if (message.role !== "user") continue;
+    const content = Array.isArray(message.content) ? message.content : [];
+    const text2 = content.filter((part) => part.type === "text").map((part) => stripSystemReminders(part.text)).filter(Boolean).join("\n").trim();
+    if (text2) return text2;
   }
-  shift() {
-    const value = this.#values.shift();
-    if (value !== void 0) return Promise.resolve(value);
-    return new Promise((resolve) => this.#waiters.push(resolve));
+  return "";
+}
+function stripSystemReminders(value) {
+  return value.replace(SYSTEM_REMINDER_RE, (block) => {
+    const wrapped = WRAPPED_USER_RE.exec(block);
+    return wrapped?.[1]?.trim() ?? "";
+  }).trim();
+}
+
+// src/provider/session-context.ts
+function readSessionID(options) {
+  const providerBlock = readProviderBlock(options);
+  if (typeof providerBlock?.workflowSessionID === "string" && providerBlock.workflowSessionID.trim()) {
+    return providerBlock.workflowSessionID.trim();
   }
-};
+  const headers = options.headers ?? {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === "x-opencode-session" && value?.trim()) return value.trim();
+  }
+  return void 0;
+}
+function readProviderBlock(options) {
+  const block = options.providerOptions?.[PROVIDER_ID];
+  if (block && typeof block === "object" && !Array.isArray(block)) {
+    return block;
+  }
+  return void 0;
+}
 
 // src/provider/duo-workflow-model.ts
 var sessions = /* @__PURE__ */ new Map();
+var UNKNOWN_USAGE = {
+  inputTokens: void 0,
+  outputTokens: void 0,
+  totalTokens: void 0
+};
 var DuoWorkflowModel = class {
   specificationVersion = "v2";
   provider = PROVIDER_ID;
   modelId;
   supportedUrls = {};
   #client;
-  constructor(modelId, client) {
+  #cwd;
+  #toolsConfig;
+  constructor(modelId, client, cwd) {
     this.modelId = modelId;
     this.#client = client;
+    this.#cwd = cwd ?? process.cwd();
+  }
+  /** Set the tools configuration for new and existing sessions. */
+  setToolsConfig(config) {
+    this.#toolsConfig = config;
+    for (const session of sessions.values()) {
+      session.setToolsConfig(config);
+    }
   }
   async doGenerate(options) {
     const sessionID = readSessionID(options);
@@ -763,11 +1249,7 @@ var DuoWorkflowModel = class {
         }
       ],
       finishReason: "stop",
-      usage: {
-        inputTokens: void 0,
-        outputTokens: void 0,
-        totalTokens: void 0
-      },
+      usage: UNKNOWN_USAGE,
       warnings: []
     };
   }
@@ -812,11 +1294,7 @@ var DuoWorkflowModel = class {
             controller.enqueue({
               type: "finish",
               finishReason: "stop",
-              usage: {
-                inputTokens: void 0,
-                outputTokens: void 0,
-                totalTokens: void 0
-              }
+              usage: UNKNOWN_USAGE
             });
             controller.close();
           } catch (error) {
@@ -827,11 +1305,7 @@ var DuoWorkflowModel = class {
             controller.enqueue({
               type: "finish",
               finishReason: "error",
-              usage: {
-                inputTokens: void 0,
-                outputTokens: void 0,
-                totalTokens: void 0
-              }
+              usage: UNKNOWN_USAGE
             });
             controller.close();
           }
@@ -845,57 +1319,28 @@ var DuoWorkflowModel = class {
       }
     };
   }
+  /** Remove a cached session, freeing its resources. */
+  disposeSession(sessionID) {
+    return sessions.delete(sessionKey(this.#client.instanceUrl, this.modelId, sessionID));
+  }
   #resolveSession(sessionID) {
-    const key = `${this.#client.instanceUrl}::${this.modelId}::${sessionID}`;
+    const key = sessionKey(this.#client.instanceUrl, this.modelId, sessionID);
     const existing = sessions.get(key);
     if (existing) return existing;
-    const created = new WorkflowSession(this.#client, this.modelId);
+    const created = new WorkflowSession(this.#client, this.modelId, this.#cwd);
+    const config = this.#toolsConfig ?? getToolsConfig();
+    if (config) created.setToolsConfig(config);
     sessions.set(key, created);
     return created;
   }
 };
-function extractGoal(prompt) {
-  for (let i = prompt.length - 1; i >= 0; i--) {
-    const message = prompt[i];
-    if (message.role !== "user") continue;
-    const content = Array.isArray(message.content) ? message.content : [];
-    const text2 = content.filter((part) => part.type === "text").map((part) => stripSystemReminders(part.text)).filter(Boolean).join("\n").trim();
-    if (text2) return text2;
-  }
-  return "";
-}
-var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
-var WRAPPED_USER_RE = /^<system-reminder>\s*The user sent the following message:\s*\n([\s\S]*?)\n\s*Please address this message and continue with your tasks\.\s*<\/system-reminder>$/;
-function stripSystemReminders(value) {
-  return value.replace(SYSTEM_REMINDER_RE, (block) => {
-    const wrapped = WRAPPED_USER_RE.exec(block);
-    return wrapped?.[1]?.trim() ?? "";
-  }).trim();
-}
-function readSessionID(options) {
-  const providerBlock = readProviderBlock(options);
-  if (typeof providerBlock?.workflowSessionID === "string" && providerBlock.workflowSessionID.trim()) {
-    return providerBlock.workflowSessionID.trim();
-  }
-  const headers = options.headers ?? {};
-  for (const [key, value] of Object.entries(headers)) {
-    if (key.toLowerCase() === "x-opencode-session" && value?.trim()) return value.trim();
-  }
-  return void 0;
-}
-function readProviderBlock(options) {
-  const block = options.providerOptions?.[PROVIDER_ID];
-  if (block && typeof block === "object" && !Array.isArray(block)) {
-    return block;
-  }
-  return void 0;
+function sessionKey(instanceUrl, modelId, sessionID) {
+  return `${instanceUrl}::${modelId}::${sessionID}`;
 }
 
 // src/provider/index.ts
 function createFallbackProvider(input = {}) {
-  const instanceUrl = normalizeInstanceUrl(input.instanceUrl ?? envInstanceUrl());
-  const token = text(input.apiKey) ?? text(input.token) ?? process.env.GITLAB_TOKEN ?? process.env.GITLAB_OAUTH_TOKEN ?? "";
-  const client = { instanceUrl, token };
+  const client = resolveCredentials(input);
   return {
     languageModel(modelId) {
       return new DuoWorkflowModel(modelId, client);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gitlab-duo-agentic",
-  "version": "0.1.23",
+  "version": "0.2.1",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",
@@ -43,9 +43,6 @@
     "@ai-sdk/provider": "2.0.1",
     "@opencode-ai/plugin": "^1.2.6",
     "isomorphic-ws": "^5.0.0",
-    "neverthrow": "^8.2.0",
-    "proxy-agent": "^6.5.0",
-    "uuid": "^11.0.5",
     "zod": "^3.25.76"
   },
   "devDependencies": {