opencode-gitlab-duo-agentic 0.1.0

package/dist/index.js

@@ -0,0 +1,2368 @@
+// src/plugin/config.ts
+import path2 from "path";
+import fs2 from "fs";
+
+// src/plugin/models.ts
+import path from "path";
+import fs from "fs";
+
+// src/shared/model_entry.ts
+function buildModelEntry(name) {
+  return {
+    name,
+    release_date: "",
+    attachment: false,
+    reasoning: false,
+    temperature: true,
+    tool_call: true,
+    limit: { context: 0, output: 0 },
+    modalities: { input: ["text"], output: ["text"] },
+    options: {}
+  };
+}
+
+// src/shared/constants.ts
+var GITLAB_DUO_PROVIDER_ID = "gitlab-duo-agentic";
+var GITLAB_DUO_DEFAULT_MODEL_ID = "duo-agentic";
+var GITLAB_DUO_DEFAULT_MODEL_NAME = "Duo Agentic";
+var GITLAB_DUO_PLUGIN_PACKAGE_NAME = "opencode-gitlab-duo-agentic";
+var GITLAB_DUO_PROVIDER_NPM_ENTRY = GITLAB_DUO_PLUGIN_PACKAGE_NAME;
+
+// src/plugin/models.ts
+async function loadGitLabModels(options = {}) {
+  const modelsJsonPath = resolveModelsJsonPath(options.modelsPath);
+  if (modelsJsonPath) {
+    try {
+      const raw = await fs.promises.readFile(modelsJsonPath, "utf8");
+      const data = JSON.parse(raw);
+      if (data.models && Object.keys(data.models).length > 0) {
+        console.log(
+          `[gitlab-duo] Loaded ${Object.keys(data.models).length} model(s) from ${modelsJsonPath}`
+        );
+        return data.models;
+      }
+    } catch (error) {
+      console.warn(
+        `[gitlab-duo] Failed to read models.json at ${modelsJsonPath}:`,
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+  return {
+    [GITLAB_DUO_DEFAULT_MODEL_ID]: buildModelEntry(GITLAB_DUO_DEFAULT_MODEL_NAME)
+  };
+}
+function resolveModelsJsonPath(overridePath) {
+  const override = typeof overridePath === "string" && overridePath.trim() ? overridePath.trim() : process.env.GITLAB_DUO_MODELS_PATH;
+  if (override) {
+    const resolved = path.isAbsolute(override) ? override : path.resolve(process.cwd(), override);
+    if (fs.existsSync(resolved)) return resolved;
+    console.warn(`[gitlab-duo] models.json not found at override path ${resolved}`);
+    return null;
+  }
+  let current = process.cwd();
+  while (true) {
+    const candidate = path.join(current, "models.json");
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+// src/plugin/config.ts
+async function configHook(input) {
+  input.provider ??= {};
+  const existing = input.provider[GITLAB_DUO_PROVIDER_ID];
+  const existingOptions = existing?.options ?? {};
+  const providerNpm = typeof existing?.npm === "string" && existing.npm.trim() ? existing.npm : GITLAB_DUO_PROVIDER_NPM_ENTRY;
+  const apiKey = typeof existingOptions.apiKey === "string" ? existingOptions.apiKey : process.env.GITLAB_TOKEN || "";
+  const instanceUrl = typeof existingOptions.instanceUrl === "string" ? existingOptions.instanceUrl : process.env.GITLAB_INSTANCE_URL || "https://gitlab.com";
+  const systemRules = typeof existingOptions.systemRules === "string" ? existingOptions.systemRules : "";
+  const systemRulesPath = typeof existingOptions.systemRulesPath === "string" ? existingOptions.systemRulesPath : "";
+  const modelsPath = typeof existingOptions.modelsPath === "string" ? existingOptions.modelsPath : void 0;
+  const mergedSystemRules = await mergeSystemRules(systemRules, systemRulesPath);
+  const sendSystemContext = typeof existingOptions.sendSystemContext === "boolean" ? existingOptions.sendSystemContext : true;
+  const enableMcp = typeof existingOptions.enableMcp === "boolean" ? existingOptions.enableMcp : true;
+  if (!apiKey) {
+    console.warn(
+      "[gitlab-duo] GITLAB_TOKEN is empty for the OpenCode process. Ensure it is exported in the same shell."
+    );
+  }
+  input.provider[GITLAB_DUO_PROVIDER_ID] = {
+    name: existing?.name ?? "GitLab Duo Agentic",
+    npm: providerNpm,
+    options: {
+      ...existingOptions,
+      instanceUrl,
+      apiKey,
+      sendSystemContext,
+      enableMcp,
+      systemRules: mergedSystemRules || void 0
+    },
+    models: await loadGitLabModels({ modelsPath })
+  };
+}
+async function mergeSystemRules(rules, rulesPath) {
+  const baseRules = rules.trim();
+  if (!rulesPath) return baseRules;
+  const resolvedPath = path2.isAbsolute(rulesPath) ? rulesPath : path2.resolve(process.cwd(), rulesPath);
+  try {
+    const fileRules = (await fs2.promises.readFile(resolvedPath, "utf8")).trim();
+    if (!fileRules) return baseRules;
+    return baseRules ? `${baseRules}
+
+${fileRules}` : fileRules;
+  } catch (error) {
+    console.warn(`[gitlab-duo] Failed to read systemRulesPath at ${resolvedPath}:`, error);
+    return baseRules;
+  }
+}
+
+// src/plugin/tools.ts
+import { tool } from "@opencode-ai/plugin";
+import path3 from "path";
+import fs3 from "fs";
+function createReadTools() {
+  return {
+    read_file: tool({
+      description: "Read the contents of a file. Paths are relative to the repository root.",
+      args: {
+        file_path: tool.schema.string().describe("The file path to read.")
+      },
+      async execute(args, ctx) {
+        const { resolvedPath, displayPath } = resolveReadPath(args.file_path, ctx);
+        await ctx.ask({
+          permission: "read",
+          patterns: [resolvedPath],
+          always: ["*"],
+          metadata: {}
+        });
+        try {
+          return await fs3.promises.readFile(resolvedPath, "utf8");
+        } catch (error) {
+          throw new Error(formatReadError(displayPath, error));
+        }
+      }
+    }),
+    read_files: tool({
+      description: "Read the contents of multiple files. Paths are relative to the repository root.",
+      args: {
+        file_paths: tool.schema.array(tool.schema.string()).describe("The file paths to read.")
+      },
+      async execute(args, ctx) {
+        const targets = (args.file_paths ?? []).map((filePath) => ({
+          inputPath: filePath,
+          ...resolveReadPath(filePath, ctx)
+        }));
+        await ctx.ask({
+          permission: "read",
+          patterns: targets.map((target) => target.resolvedPath),
+          always: ["*"],
+          metadata: {}
+        });
+        const results = await Promise.all(
+          targets.map(async (target) => {
+            try {
+              const content = await fs3.promises.readFile(target.resolvedPath, "utf8");
+              return [target.inputPath, { content }];
+            } catch (error) {
+              return [target.inputPath, { error: formatReadError(target.displayPath, error) }];
+            }
+          })
+        );
+        const output = {};
+        for (const [pathKey, result] of results) {
+          output[pathKey] = result;
+        }
+        return JSON.stringify(output);
+      }
+    })
+  };
+}
+function resolveReadPath(filePath, ctx) {
+  const displayPath = filePath;
+  const resolvedPath = path3.isAbsolute(filePath) ? filePath : path3.resolve(ctx.worktree, filePath);
+  const worktreePath = path3.resolve(ctx.worktree);
+  if (resolvedPath !== worktreePath && !resolvedPath.startsWith(worktreePath + path3.sep)) {
+    throw new Error(`File is outside the repository: "${displayPath}"`);
+  }
+  return { resolvedPath, displayPath };
+}
+function formatReadError(filePath, error) {
+  const fsError = error;
+  if (fsError?.code === "ENOENT") return `File not found: "${filePath}"`;
+  const message = error instanceof Error ? error.message : String(error);
+  return `Error reading file: ${message}`;
+}
+
+// src/plugin/gitlab-duo-agentic.ts
+var GitLabDuoAgenticPlugin = async () => {
+  return {
+    config: configHook,
+    tool: createReadTools()
+  };
+};
+
+// src/provider/core/stream_adapter.ts
+import { createRequire } from "module";
+function resolveReadableStream() {
+  if (typeof ReadableStream !== "undefined") {
+    return ReadableStream;
+  }
+  const require2 = createRequire(import.meta.url);
+  const web = require2("node:stream/web");
+  return web.ReadableStream;
+}
+function asyncIteratorToReadableStream(iter) {
+  const iterator = iter[Symbol.asyncIterator]();
+  const Readable = resolveReadableStream();
+  return new Readable({
+    async pull(controller) {
+      try {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel() {
+      if (iterator.return) {
+        await iterator.return();
+      }
+    }
+  });
+}
+
+// src/provider/core/prompt_utils.ts
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+function extractLastUserText(prompt) {
+  const parts = getLastUserTextParts(prompt);
+  if (parts.length === 0) return null;
+  const texts = parts.filter((part) => !part.synthetic && !part.ignored).map((part) => stripSystemReminder(part.text ?? "")).filter((text) => text.trim().length > 0);
+  if (texts.length === 0) return null;
+  return texts.join("").trim();
+}
+function getLastUserTextParts(prompt) {
+  if (!Array.isArray(prompt)) return [];
+  for (let i = prompt.length - 1; i >= 0; i -= 1) {
+    const message = prompt[i];
+    if (message?.role !== "user" || !Array.isArray(message.content)) continue;
+    const textParts = message.content.filter((part) => part.type === "text");
+    if (textParts.length > 0) return textParts;
+  }
+  return [];
+}
+function stripSystemReminder(text) {
+  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
+}
+function extractAgentReminders(prompt) {
+  const parts = getLastUserTextParts(prompt);
+  if (parts.length === 0) return [];
+  const reminders = [];
+  for (const part of parts) {
+    if (!part.text) continue;
+    if (part.synthetic) {
+      const text = part.text.trim();
+      if (text.length > 0) {
+        reminders.push(text);
+      }
+      continue;
+    }
+    const matches = part.text.match(/<system-reminder>[\s\S]*?<\/system-reminder>/g);
+    if (matches) {
+      reminders.push(...matches);
+    }
+  }
+  return normalizeModeReminders(reminders);
+}
+function normalizeModeReminders(reminders) {
+  const mode = detectLatestMode(reminders);
+  if (!mode) return reminders;
+  return reminders.filter((reminder) => {
+    const classification = classifyModeReminder(reminder);
+    if (classification === "other") return true;
+    return classification === mode;
+  });
+}
+function detectLatestMode(reminders) {
+  let mode = null;
+  for (const reminder of reminders) {
+    const explicit = /operational mode has changed from\s+([a-z_]+)\s+to\s+([a-z_]+)/i.exec(reminder);
+    if (explicit) {
+      const normalized = normalizeMode(explicit[2]);
+      if (normalized) mode = normalized;
+      continue;
+    }
+    const classification = classifyModeReminder(reminder);
+    if (classification !== "other") {
+      mode = classification;
+    }
+  }
+  return mode;
+}
+function normalizeMode(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "plan") return "plan";
+  if (normalized === "build") return "build";
+  return null;
+}
+function classifyModeReminder(reminder) {
+  const text = reminder.toLowerCase();
+  if (text.includes("operational mode has changed from build to plan")) return "plan";
+  if (text.includes("operational mode has changed from plan to build")) return "build";
+  if (text.includes("you are no longer in read-only mode")) return "build";
+  if (text.includes("you are in read-only mode")) return "plan";
+  if (text.includes("your operational mode has changed from plan to build")) return "build";
+  if (text.includes("your operational mode has changed from build to plan")) return "plan";
+  if (text.includes("you are permitted to make file changes")) return "build";
+  return "other";
+}
+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 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) {
+      if (part.type === "tool-result") {
+        const toolCallId = String(part.toolCallId ?? "");
+        const toolName = String(part.toolName ?? "");
+        const outputField = part.output;
+        const resultField = part.result;
+        let output = "";
+        let error;
+        if (isPlainObject(outputField) && "type" in outputField) {
+          const outputType = String(outputField.type);
+          const outputValue = outputField.value;
+          if (outputType === "text" || outputType === "json") {
+            output = typeof outputValue === "string" ? outputValue : JSON.stringify(outputValue ?? "");
+          } else if (outputType === "error-text" || outputType === "error-json") {
+            error = typeof outputValue === "string" ? outputValue : JSON.stringify(outputValue ?? "");
+          } else if (outputType === "content" && Array.isArray(outputValue)) {
+            output = outputValue.filter((v) => v.type === "text").map((v) => String(v.text ?? "")).join("\n");
+          }
+        } else if (outputField !== void 0) {
+          output = String(outputField);
+        } else if (resultField !== void 0) {
+          output = typeof resultField === "string" ? resultField : JSON.stringify(resultField);
+          if (isPlainObject(resultField)) error = asString(resultField.error);
+        }
+        if (!error) {
+          error = asString(part.error) ?? asString(part.errorText);
+        }
+        results.push({ toolCallId, toolName, output, error });
+      }
+      if (part.type === "tool-error") {
+        const toolCallId = String(part.toolCallId ?? "");
+        const toolName = String(part.toolName ?? "");
+        const errorValue = part.error ?? part.errorText ?? part.message;
+        const error = asString(errorValue) ?? String(errorValue ?? "");
+        results.push({ toolCallId, toolName, output: "", error });
+      }
+    }
+  }
+  return results;
+}
+
+// src/provider/core/shell_quote.ts
+function shellQuote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+// src/provider/application/tool_mapping.ts
+function mapDuoToolRequest(toolName, args) {
+  switch (toolName) {
+    case "list_dir": {
+      const directory = asString(args.directory) ?? ".";
+      return {
+        toolName: "bash",
+        args: {
+          command: `ls -la ${shellQuote(directory)}`,
+          description: "List directory contents",
+          workdir: "."
+        }
+      };
+    }
+    case "read_file": {
+      const filePath = asString(args.file_path) ?? asString(args.filepath) ?? asString(args.filePath) ?? asString(args.path);
+      if (!filePath) return { toolName, args };
+      const mappedArgs = { filePath };
+      if (typeof args.offset === "number") mappedArgs.offset = args.offset;
+      if (typeof args.limit === "number") mappedArgs.limit = args.limit;
+      return { toolName: "read", args: mappedArgs };
+    }
+    case "read_files": {
+      const filePaths = asStringArray(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 = asString(args.file_path);
+      const content = asString(args.contents);
+      if (!filePath || content === void 0) return { toolName, args };
+      return { toolName: "write", args: { 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 { toolName, args };
+      return { toolName: "edit", args: { filePath, oldString, newString } };
+    }
+    case "find_files": {
+      const pattern = asString(args.name_pattern);
+      if (!pattern) return { toolName, args };
+      return { toolName: "glob", args: { pattern } };
+    }
+    case "grep": {
+      const pattern = asString(args.pattern);
+      if (!pattern) return { toolName, args };
+      const searchDirectory = asString(args.search_directory);
+      const caseInsensitive = Boolean(args.case_insensitive);
+      const normalizedPattern = caseInsensitive && !pattern.startsWith("(?i)") ? `(?i)${pattern}` : pattern;
+      const mappedArgs = { pattern: normalizedPattern };
+      if (searchDirectory) mappedArgs.path = searchDirectory;
+      return { toolName: "grep", args: mappedArgs };
+    }
+    case "mkdir": {
+      const directory = asString(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 = asString(args.command);
+      if (!command) return { toolName, args };
+      return {
+        toolName: "bash",
+        args: { command, description: "Run shell command", workdir: "." }
+      };
+    }
+    case "run_command": {
+      const program = asString(args.program);
+      if (program) {
+        const parts = [shellQuote(program)];
+        const flags = args.flags;
+        if (Array.isArray(flags)) parts.push(...flags.map((f) => shellQuote(String(f))));
+        const cmdArgs = args.arguments;
+        if (Array.isArray(cmdArgs)) parts.push(...cmdArgs.map((a) => shellQuote(String(a))));
+        return {
+          toolName: "bash",
+          args: { command: parts.join(" "), description: "Run command", workdir: "." }
+        };
+      }
+      const command = asString(args.command);
+      if (!command) return { toolName, args };
+      return {
+        toolName: "bash",
+        args: { command, description: "Run command", workdir: "." }
+      };
+    }
+    case "run_git_command": {
+      const command = asString(args.command);
+      if (!command) return { toolName, args };
+      const rawArgs = args.args;
+      const extraArgs = Array.isArray(rawArgs) ? rawArgs.map((value) => shellQuote(String(value))).join(" ") : asString(rawArgs);
+      const gitCommand = extraArgs ? `git ${shellQuote(command)} ${extraArgs}` : `git ${shellQuote(command)}`;
+      return {
+        toolName: "bash",
+        args: { command: gitCommand, description: "Run git command", workdir: "." }
+      };
+    }
+    default:
+      return { toolName, args };
+  }
+}
+var DUO_MCP_TOOLS = [
+  {
+    name: "list_dir",
+    description: "List directory contents relative to the repository root.",
+    schema: {
+      type: "object",
+      properties: {
+        directory: { type: "string", description: "Directory path relative to repo root." }
+      },
+      required: ["directory"]
+    }
+  },
+  {
+    name: "read_file",
+    description: "Read the contents of a file.",
+    schema: {
+      type: "object",
+      properties: {
+        file_path: { type: "string", description: "The file path to read." }
+      },
+      required: ["file_path"]
+    }
+  },
+  {
+    name: "read_files",
+    description: "Read multiple files.",
+    schema: {
+      type: "object",
+      properties: {
+        file_paths: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of file paths to read."
+        }
+      },
+      required: ["file_paths"]
+    }
+  },
+  {
+    name: "create_file_with_contents",
+    description: "Create a file and write contents.",
+    schema: {
+      type: "object",
+      properties: {
+        file_path: { type: "string", description: "The file path to write." },
+        contents: { type: "string", description: "Contents to write." }
+      },
+      required: ["file_path", "contents"]
+    }
+  },
+  {
+    name: "find_files",
+    description: "Find files by name pattern.",
+    schema: {
+      type: "object",
+      properties: {
+        name_pattern: { type: "string", description: "Pattern to search for." }
+      },
+      required: ["name_pattern"]
+    }
+  },
+  {
+    name: "mkdir",
+    description: "Create a directory.",
+    schema: {
+      type: "object",
+      properties: {
+        directory_path: { type: "string", description: "Directory to create." }
+      },
+      required: ["directory_path"]
+    }
+  },
+  {
+    name: "edit_file",
+    description: "Edit a file by replacing a string.",
+    schema: {
+      type: "object",
+      properties: {
+        file_path: { type: "string", description: "Path of the file to edit." },
+        old_str: { type: "string", description: "String to replace." },
+        new_str: { type: "string", description: "Replacement string." }
+      },
+      required: ["file_path", "old_str", "new_str"]
+    }
+  },
+  {
+    name: "grep",
+    description: "Search for a pattern in files.",
+    schema: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "Search pattern." },
+        search_directory: { type: "string", description: "Directory to search." },
+        case_insensitive: { type: "boolean", description: "Case insensitive search." }
+      },
+      required: ["pattern"]
+    }
+  },
+  {
+    name: "shell_command",
+    description: "Execute a shell command.",
+    schema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "Command to execute." }
+      },
+      required: ["command"]
+    }
+  },
+  {
+    name: "run_git_command",
+    description: "Run a git command in the repo.",
+    schema: {
+      type: "object",
+      properties: {
+        repository_url: { type: "string", description: "Git remote URL." },
+        command: { type: "string", description: "Git command (status, log, diff, ...)." },
+        args: { type: "string", description: "Arguments for the git command." }
+      },
+      required: ["repository_url", "command"]
+    }
+  }
+];
+var BUILTIN_TOOL_NAMES = new Set(DUO_MCP_TOOLS.map((t) => t.name));
+var OPENCODE_BUILTIN_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "bash",
+  "edit",
+  "write",
+  "read",
+  "grep",
+  "glob",
+  "patch",
+  "skill",
+  "todowrite",
+  "todoread",
+  "webfetch",
+  "websearch",
+  "question",
+  "lsp",
+  "read_file",
+  "read_files"
+]);
+function buildMcpTools(options) {
+  const tools = DUO_MCP_TOOLS.map((t) => ({
+    name: t.name,
+    description: t.description,
+    schema: t.schema,
+    isApproved: false
+  }));
+  if (options.tools) {
+    for (const t of options.tools) {
+      if (t.type !== "function") continue;
+      if (BUILTIN_TOOL_NAMES.has(t.name)) continue;
+      if (OPENCODE_BUILTIN_TOOL_NAMES.has(t.name)) continue;
+      tools.push({
+        name: t.name,
+        description: t.description,
+        schema: t.inputSchema,
+        isApproved: false
+      });
+    }
+  }
+  return tools;
+}
+function buildToolContext(tools) {
+  if (tools.length === 0) return null;
+  const content = `<tools>
+${tools.map((t) => {
+    const desc = t.description?.trim();
+    return desc ? `- ${t.name}: ${desc}` : `- ${t.name}`;
+  }).join("\n")}
+</tools>
+<rules>
+- MUST use the tool-call simulation formats when requesting tools.
+</rules>`;
+  return {
+    category: "tool_information",
+    content,
+    id: "available_tools",
+    metadata: {
+      title: "Available Tools",
+      enabled: true,
+      subType: "tools",
+      icon: "tool",
+      secondaryText: `${tools.length} tools`,
+      subTypeLabel: "Tooling"
+    }
+  };
+}
+
+// src/provider/core/token_usage.ts
+var DEFAULT_CHARS_PER_TOKEN = 4;
+var TokenUsageEstimator = class {
+  #inputChars = 0;
+  #outputChars = 0;
+  #charsPerToken;
+  constructor(charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
+    this.#charsPerToken = charsPerToken;
+  }
+  /** Record characters sent to DWS (prompt, system context, tool results). */
+  addInputChars(text) {
+    this.#inputChars += text.length;
+  }
+  /** Record characters received from DWS (text chunks, tool call args). */
+  addOutputChars(text) {
+    this.#outputChars += text.length;
+  }
+  get inputTokens() {
+    return Math.ceil(this.#inputChars / this.#charsPerToken);
+  }
+  get outputTokens() {
+    return Math.ceil(this.#outputChars / this.#charsPerToken);
+  }
+  get totalTokens() {
+    return this.inputTokens + this.outputTokens;
+  }
+  /** Reset counters for a new turn. */
+  reset() {
+    this.#inputChars = 0;
+    this.#outputChars = 0;
+  }
+};
+
+// src/provider/application/model.ts
+var GitLabDuoAgenticLanguageModel = class {
+  specificationVersion = "v2";
+  provider = GITLAB_DUO_PROVIDER_ID;
+  modelId;
+  supportedUrls = {};
+  #options;
+  #runtime;
+  #pendingToolRequests = /* @__PURE__ */ new Map();
+  #multiCallGroups = /* @__PURE__ */ new Map();
+  #sentToolCallIds = /* @__PURE__ */ new Set();
+  #lastSentPrompt = null;
+  #agentMode;
+  #agentModeReminder;
+  #usageEstimator = new TokenUsageEstimator();
+  constructor(modelId, options, runtime) {
+    this.modelId = modelId;
+    this.#options = options;
+    this.#runtime = runtime;
+  }
+  // ---------------------------------------------------------------------------
+  // LanguageModelV2 interface
+  // ---------------------------------------------------------------------------
+  async doGenerate(options) {
+    let text = "";
+    const stream = await this.doStream(options);
+    for await (const part of stream.stream) {
+      if (part.type === "text-delta") text += part.delta;
+    }
+    const content = [{ type: "text", text }];
+    const finishReason = "stop";
+    return {
+      content,
+      finishReason,
+      usage: {
+        inputTokens: this.#usageEstimator.inputTokens,
+        outputTokens: this.#usageEstimator.outputTokens,
+        totalTokens: this.#usageEstimator.totalTokens
+      },
+      warnings: []
+    };
+  }
+  async doStream(options) {
+    const workflowType = "chat";
+    const promptText = extractLastUserText(options.prompt);
+    const toolResults = extractToolResults(options.prompt);
+    this.#runtime.resetMapperState();
+    if (!this.#runtime.hasStarted) {
+      this.#sentToolCallIds.clear();
+      for (const r of toolResults) {
+        if (!this.#pendingToolRequests.has(r.toolCallId)) {
+          this.#sentToolCallIds.add(r.toolCallId);
+        }
+      }
+      this.#lastSentPrompt = null;
+    }
+    const freshToolResults = toolResults.filter((r) => !this.#sentToolCallIds.has(r.toolCallId));
+    const modelRef = this.modelId === GITLAB_DUO_DEFAULT_MODEL_ID ? void 0 : this.modelId;
+    this.#runtime.setSelectedModelIdentifier(modelRef);
+    await this.#runtime.ensureConnected(promptText || "", workflowType);
+    const mcpTools = this.#options.enableMcp === false ? [] : buildMcpTools(options);
+    const toolContext = buildToolContext(mcpTools);
+    const isNewUserMessage = promptText != null && promptText !== this.#lastSentPrompt;
+    let sentToolResults = false;
+    if (freshToolResults.length > 0) {
+      for (const result of freshToolResults) {
+        const hashIdx = result.toolCallId.indexOf("#");
+        if (hashIdx !== -1) {
+          const originalId = result.toolCallId.substring(0, hashIdx);
+          const group = this.#multiCallGroups.get(originalId);
+          if (!group) {
+            this.#sentToolCallIds.add(result.toolCallId);
+            continue;
+          }
+          this.#usageEstimator.addInputChars(result.output);
+          if (result.error) this.#usageEstimator.addInputChars(result.error);
+          group.collected.set(result.toolCallId, result.error ?? result.output);
+          this.#sentToolCallIds.add(result.toolCallId);
+          this.#pendingToolRequests.delete(result.toolCallId);
+          if (group.collected.size === group.subIds.length) {
+            const aggregated = group.subIds.map((id) => group.collected.get(id) ?? "").join("\n");
+            this.#runtime.sendToolResponse(
+              originalId,
+              { output: aggregated },
+              group.responseType
+            );
+            this.#multiCallGroups.delete(originalId);
+            this.#pendingToolRequests.delete(originalId);
+            sentToolResults = true;
+          }
+          continue;
+        }
+        const pending = this.#pendingToolRequests.get(result.toolCallId);
+        if (!pending) {
+          this.#sentToolCallIds.add(result.toolCallId);
+          continue;
+        }
+        this.#usageEstimator.addInputChars(result.output);
+        if (result.error) this.#usageEstimator.addInputChars(result.error);
+        this.#runtime.sendToolResponse(
+          result.toolCallId,
+          { output: result.output, error: result.error },
+          pending.responseType
+        );
+        sentToolResults = true;
+        this.#sentToolCallIds.add(result.toolCallId);
+        this.#pendingToolRequests.delete(result.toolCallId);
+      }
+    }
+    if (!sentToolResults && isNewUserMessage) {
+      const extraContext = [];
+      if (toolContext) extraContext.push(toolContext);
+      if (!this.#runtime.hasStarted) {
+        const systemPrompt = extractSystemPrompt(options.prompt);
+        if (systemPrompt) {
+          extraContext.push({
+            category: "agent_context",
+            content: sanitizeSystemPrompt(systemPrompt),
+            id: "agent_system_prompt",
+            metadata: {
+              title: "Agent System Prompt",
+              enabled: true,
+              subType: "system_prompt",
+              icon: "file-text",
+              secondaryText: "Full system prompt",
+              subTypeLabel: "System Prompt"
+            }
+          });
+        }
+      } else {
+        const promptContent = extractSystemPrompt(options.prompt);
+        if (promptContent) {
+          extraContext.push({
+            category: "agent_context",
+            content: sanitizeSystemPrompt(promptContent),
+            id: "agent_system_prompt",
+            metadata: {
+              title: "Agent System Prompt",
+              enabled: true,
+              subType: "system_prompt",
+              icon: "file-text",
+              secondaryText: "System prompt",
+              subTypeLabel: "System Prompt"
+            }
+          });
+        }
+      }
+      const agentReminders = extractAgentReminders(options.prompt);
+      const modeReminder = detectLatestModeReminder(agentReminders);
+      if (modeReminder) {
+        this.#agentMode = modeReminder.mode;
+        this.#agentModeReminder = modeReminder.reminder;
+      }
+      const remindersForContext = buildReminderContext(agentReminders, this.#agentModeReminder);
+      if (remindersForContext.length > 0) {
+        const reminderContent = sanitizeSystemPrompt(remindersForContext.join("\n\n"));
+        extraContext.push({
+          category: "agent_context",
+          content: reminderContent,
+          id: "agent_reminders",
+          metadata: {
+            title: "Agent Reminders",
+            enabled: true,
+            subType: "agent_reminders",
+            icon: "file-text",
+            secondaryText: "Agent mode instructions",
+            subTypeLabel: "Agent Reminders"
+          }
+        });
+      }
+      this.#runtime.sendStartRequest(
+        promptText,
+        workflowType,
+        mcpTools,
+        [],
+        extraContext
+      );
+      this.#lastSentPrompt = promptText;
+      this.#usageEstimator.addInputChars(promptText);
+      for (const ctx of extraContext) {
+        if (ctx.content) this.#usageEstimator.addInputChars(ctx.content);
+      }
+    }
+    const iterator = this.#mapEventsToStream(this.#runtime.getEventStream());
+    const stream = asyncIteratorToReadableStream(iterator);
+    return {
+      stream
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Event → stream mapping (2 paths: TEXT_CHUNK + TOOL_REQUEST)
+  // ---------------------------------------------------------------------------
+  async *#mapEventsToStream(events) {
+    const state = { textStarted: false };
+    const estimator = this.#usageEstimator;
+    yield { type: "stream-start", warnings: [] };
+    try {
+      for await (const event of events) {
+        if (event.type === "TEXT_CHUNK") {
+          if (event.content.length > 0) {
+            estimator.addOutputChars(event.content);
+            yield* this.#emitTextDelta(state, event.content);
+          }
+          continue;
+        }
+        if (event.type === "TOOL_COMPLETE") {
+          continue;
+        }
+        if (event.type === "TOOL_REQUEST") {
+          const args = event.args;
+          let mapped;
+          try {
+            mapped = mapDuoToolRequest(event.toolName, args);
+          } catch {
+            continue;
+          }
+          const responseType = event.responseType;
+          estimator.addOutputChars(JSON.stringify(args));
+          if (Array.isArray(mapped)) {
+            const subIds = mapped.map((_, i) => `${event.requestId}#${i}`);
+            this.#multiCallGroups.set(event.requestId, { subIds, collected: /* @__PURE__ */ new Map(), responseType });
+            this.#pendingToolRequests.set(event.requestId, { responseType });
+            for (const subId of subIds) {
+              this.#pendingToolRequests.set(subId, {});
+            }
+            yield* this.#emitMultiToolCalls(subIds, mapped);
+            return;
+          }
+          this.#pendingToolRequests.set(event.requestId, { responseType });
+          yield* this.#emitToolCall(event.requestId, mapped.toolName, mapped.args);
+          return;
+        }
+        if (event.type === "ERROR") {
+          const msg = event.message;
+          if (msg.includes("1013") || msg.includes("lock")) {
+            yield { type: "error", error: new Error("GitLab Duo workflow is locked (another session may still be active). Please try again in a few seconds.") };
+          } else {
+            yield { type: "error", error: new Error(`GitLab Duo: ${msg}`) };
+          }
+          return;
+        }
+      }
+    } catch (streamErr) {
+      yield { type: "error", error: streamErr instanceof Error ? streamErr : new Error(String(streamErr)) };
+      return;
+    }
+    yield { type: "finish", finishReason: "stop", usage: this.#currentUsage };
+  }
+  // ---------------------------------------------------------------------------
+  // Stream part helpers
+  // ---------------------------------------------------------------------------
+  get #currentUsage() {
+    return {
+      inputTokens: this.#usageEstimator.inputTokens,
+      outputTokens: this.#usageEstimator.outputTokens,
+      totalTokens: this.#usageEstimator.totalTokens
+    };
+  }
+  *#emitTextDelta(state, delta) {
+    if (!state.textStarted) {
+      state.textStarted = true;
+      yield { type: "text-start", id: "txt-0" };
+    }
+    yield { type: "text-delta", id: "txt-0", delta };
+  }
+  *#emitToolCall(id, toolName, args) {
+    const inputJson = JSON.stringify(args ?? {});
+    yield { type: "tool-input-start", id, toolName };
+    yield { type: "tool-input-delta", id, delta: inputJson };
+    yield { type: "tool-input-end", id };
+    yield { type: "tool-call", toolCallId: id, toolName, input: inputJson };
+    yield { type: "finish", finishReason: "tool-calls", usage: this.#currentUsage };
+  }
+  *#emitMultiToolCalls(ids, calls) {
+    for (let i = 0; i < calls.length; i++) {
+      const inputJson = JSON.stringify(calls[i].args ?? {});
+      yield { type: "tool-input-start", id: ids[i], toolName: calls[i].toolName };
+      yield { type: "tool-input-delta", id: ids[i], delta: inputJson };
+      yield { type: "tool-input-end", id: ids[i] };
+      yield { type: "tool-call", toolCallId: ids[i], toolName: calls[i].toolName, input: inputJson };
+    }
+    yield { type: "finish", finishReason: "tool-calls", usage: this.#currentUsage };
+  }
+};
+function buildReminderContext(reminders, modeReminder) {
+  const nonModeReminders = reminders.filter((reminder) => classifyModeReminder2(reminder) === "other");
+  if (!modeReminder) {
+    return nonModeReminders;
+  }
+  return [...nonModeReminders, modeReminder];
+}
+function detectLatestModeReminder(reminders) {
+  let latest;
+  for (const reminder of reminders) {
+    const classification = classifyModeReminder2(reminder);
+    if (classification === "other") continue;
+    latest = { mode: classification, reminder };
+  }
+  return latest;
+}
+function classifyModeReminder2(reminder) {
+  const text = reminder.toLowerCase();
+  if (text.includes("operational mode has changed from build to plan")) return "plan";
+  if (text.includes("operational mode has changed from plan to build")) return "build";
+  if (text.includes("you are no longer in read-only mode")) return "build";
+  if (text.includes("you are now in read-only mode")) return "plan";
+  if (text.includes("you are in read-only mode")) return "plan";
+  if (text.includes("you are permitted to make file changes")) return "build";
+  return "other";
+}
+
+// src/provider/application/workflow_event_mapper.ts
+import crypto from "crypto";
+
+// src/provider/core/ui_chat_log.ts
+import { z } from "zod";
+import { err, ok } from "neverthrow";
+var ToolInfoArgsSchema = z.record(z.unknown());
+var ToolResponseSchema = z.object({
+  content: z.string(),
+  additional_kwargs: z.record(z.unknown()),
+  response_metadata: z.record(z.unknown()),
+  type: z.string(),
+  name: z.string(),
+  id: z.string().nullable(),
+  tool_call_id: z.string(),
+  artifact: z.unknown(),
+  status: z.string()
+});
+var ToolInfoSchema = z.object({
+  name: z.string(),
+  args: ToolInfoArgsSchema,
+  tool_response: z.union([ToolResponseSchema, z.string()]).optional()
+});
+var BaseMessageSchema = z.object({
+  message_sub_type: z.string().nullable(),
+  content: z.string(),
+  timestamp: z.string(),
+  status: z.string().nullable(),
+  correlation_id: z.string().nullable(),
+  additional_context: z.unknown()
+});
+var WorkflowMessageSchema = BaseMessageSchema.extend({
+  message_type: z.enum(["user", "agent"]),
+  tool_info: z.null()
+});
+var WorkflowRequestSchema = BaseMessageSchema.extend({
+  message_type: z.literal("request"),
+  tool_info: ToolInfoSchema
+});
+var WorkflowToolSchema = BaseMessageSchema.extend({
+  message_type: z.literal("tool"),
+  tool_info: z.union([ToolInfoSchema, z.null()])
+});
+var ChatLogSchema = z.discriminatedUnion("message_type", [
+  WorkflowMessageSchema,
+  WorkflowRequestSchema,
+  WorkflowToolSchema
+]);
+function extractUiChatLog(message) {
+  if (!message.checkpoint) return ok([]);
+  let checkpoint;
+  try {
+    checkpoint = JSON.parse(message.checkpoint);
+  } catch (error) {
+    const cause = error instanceof Error ? error.message : String(error);
+    return err(
+      new Error(`Failed to parse workflow checkpoint. Checkpoint: ${message.checkpoint}. Cause: ${cause}`)
+    );
+  }
+  if (!checkpoint.channel_values?.ui_chat_log || !Array.isArray(checkpoint.channel_values.ui_chat_log)) {
+    return ok([]);
+  }
+  const validatedMessages = [];
+  for (let i = 0; i < checkpoint.channel_values.ui_chat_log.length; i += 1) {
+    const rawMessage = checkpoint.channel_values.ui_chat_log[i];
+    const parseResult = ChatLogSchema.safeParse(rawMessage);
+    if (!parseResult.success) {
+      return err(
+        new Error(
+          `Failed to validate message at index ${i}: ${parseResult.error.message}. Raw message: ${JSON.stringify(
+            rawMessage
+          )}`
+        )
+      );
+    }
+    validatedMessages.push(parseResult.data);
+  }
+  return ok(validatedMessages);
+}
+
+// src/provider/application/workflow_event_mapper.ts
+var WorkflowEventMapper = class {
+  #lastMessageContent = "";
+  #lastMessageId = "";
+  resetStreamState() {
+    this.#lastMessageContent = "";
+    this.#lastMessageId = "";
+  }
+  #parseTimestamp(timestamp) {
+    const parsed = Date.parse(timestamp);
+    return Number.isNaN(parsed) ? Date.now() : parsed;
+  }
+  mapWorkflowEvent(duoEvent) {
+    const events = [];
+    const workflowMessagesResult = extractUiChatLog(duoEvent);
+    if (workflowMessagesResult.isErr()) {
+      return events;
+    }
+    const workflowMessages = workflowMessagesResult.value;
+    if (workflowMessages.length === 0) return events;
+    const latestMessage = workflowMessages[workflowMessages.length - 1];
+    const latestMessageIndex = workflowMessages.length - 1;
+    switch (latestMessage.message_type) {
+      case "user":
+        return events;
+      case "agent": {
+        const currentContent = latestMessage.content;
+        const currentId = `${latestMessageIndex}`;
+        const timestamp = this.#parseTimestamp(latestMessage.timestamp);
+        if (currentId === this.#lastMessageId) {
+          if (!currentContent.startsWith(this.#lastMessageContent)) {
+            events.push({
+              type: "TEXT_CHUNK",
+              messageId: currentId,
+              content: currentContent,
+              timestamp
+            });
+            this.#lastMessageContent = currentContent;
+          }
+          const delta = currentContent.slice(this.#lastMessageContent.length);
+          if (delta.length > 0) {
+            events.push({
+              type: "TEXT_CHUNK",
+              messageId: currentId,
+              content: delta,
+              timestamp
+            });
+            this.#lastMessageContent = currentContent;
+          }
+        } else {
+          events.push({
+            type: "TEXT_CHUNK",
+            messageId: currentId,
+            content: currentContent,
+            timestamp
+          });
+          this.#lastMessageContent = currentContent;
+          this.#lastMessageId = currentId;
+        }
+        break;
+      }
+      case "request": {
+        const requestId = latestMessage.correlation_id || crypto.randomUUID();
+        events.push({
+          type: "TOOL_REQUEST",
+          requestId,
+          toolName: latestMessage.tool_info.name,
+          args: latestMessage.tool_info.args ?? {},
+          timestamp: this.#parseTimestamp(latestMessage.timestamp)
+        });
+        break;
+      }
+      case "tool": {
+        const toolId = `${latestMessageIndex}`;
+        const timestamp = this.#parseTimestamp(latestMessage.timestamp);
+        const toolResponse = latestMessage.tool_info?.tool_response;
+        const output = typeof toolResponse === "string" ? toolResponse : toolResponse?.content ?? latestMessage.content;
+        if (output.startsWith("Action error:")) {
+          events.push({
+            type: "TOOL_COMPLETE",
+            toolId,
+            result: "",
+            error: output,
+            timestamp
+          });
+        } else {
+          events.push({
+            type: "TOOL_COMPLETE",
+            toolId,
+            result: output,
+            timestamp
+          });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    return events;
+  }
+};
+
+// src/provider/core/async_queue.ts
+var AsyncQueue = class {
+  #items = [];
+  #resolvers = [];
+  #closed = false;
+  push(item) {
+    if (this.#closed) return;
+    const resolver = this.#resolvers.shift();
+    if (resolver) {
+      resolver({ value: item, done: false });
+      return;
+    }
+    this.#items.push(item);
+  }
+  close() {
+    this.#closed = true;
+    while (this.#resolvers.length > 0) {
+      const resolver = this.#resolvers.shift();
+      if (resolver) resolver({ value: void 0, done: true });
+    }
+  }
+  async *iterate() {
+    while (true) {
+      if (this.#items.length > 0) {
+        yield this.#items.shift();
+        continue;
+      }
+      if (this.#closed) return;
+      const next = await new Promise((resolve) => {
+        this.#resolvers.push(resolve);
+      });
+      if (next.done) return;
+      yield next.value;
+    }
+  }
+};
+
+// src/provider/application/action_handler.ts
+function mapWorkflowActionToToolRequest(action) {
+  const requestId = action.requestID;
+  if (!requestId) return null;
+  if (action.runMCPTool) {
+    const rawArgs = action.runMCPTool.args;
+    let parsedArgs;
+    if (typeof rawArgs === "string") {
+      try {
+        parsedArgs = JSON.parse(rawArgs);
+      } catch {
+        parsedArgs = {};
+      }
+    } else {
+      parsedArgs = rawArgs ?? {};
+    }
+    return { requestId, toolName: action.runMCPTool.name, args: parsedArgs };
+  }
+  if (action.runReadFile) {
+    return {
+      requestId,
+      toolName: "read_file",
+      args: {
+        file_path: action.runReadFile.filepath,
+        offset: action.runReadFile.offset,
+        limit: action.runReadFile.limit
+      }
+    };
+  }
+  if (action.runReadFiles) {
+    return {
+      requestId,
+      toolName: "read_files",
+      args: { file_paths: action.runReadFiles.filepaths ?? [] }
+    };
+  }
+  if (action.runWriteFile) {
+    return {
+      requestId,
+      toolName: "create_file_with_contents",
+      args: {
+        file_path: action.runWriteFile.filepath,
+        contents: action.runWriteFile.contents
+      }
+    };
+  }
+  if (action.runEditFile) {
+    return {
+      requestId,
+      toolName: "edit_file",
+      args: {
+        file_path: action.runEditFile.filepath,
+        old_str: action.runEditFile.oldString,
+        new_str: action.runEditFile.newString
+      }
+    };
+  }
+  if (action.findFiles) {
+    return {
+      requestId,
+      toolName: "find_files",
+      args: { name_pattern: action.findFiles.name_pattern }
+    };
+  }
+  if (action.listDirectory) {
+    return {
+      requestId,
+      toolName: "list_dir",
+      args: { directory: action.listDirectory.directory }
+    };
+  }
+  if (action.grep) {
+    const args = { pattern: action.grep.pattern };
+    if (action.grep.search_directory) args.search_directory = action.grep.search_directory;
+    if (action.grep.case_insensitive !== void 0) args.case_insensitive = action.grep.case_insensitive;
+    return { requestId, toolName: "grep", args };
+  }
+  if (action.mkdir) {
+    return {
+      requestId,
+      toolName: "mkdir",
+      args: { directory_path: action.mkdir.directory_path }
+    };
+  }
+  if (action.runShellCommand) {
+    return {
+      requestId,
+      toolName: "shell_command",
+      args: { command: action.runShellCommand.command }
+    };
+  }
+  if (action.runCommand) {
+    const parts = [shellQuote(action.runCommand.program)];
+    if (action.runCommand.flags) parts.push(...action.runCommand.flags.map(shellQuote));
+    if (action.runCommand.arguments) parts.push(...action.runCommand.arguments.map(shellQuote));
+    return {
+      requestId,
+      toolName: "shell_command",
+      args: { command: parts.join(" ") }
+    };
+  }
+  if (action.runGitCommand) {
+    return {
+      requestId,
+      toolName: "run_git_command",
+      args: {
+        repository_url: action.runGitCommand.repository_url ?? "",
+        command: action.runGitCommand.command,
+        args: action.runGitCommand.arguments
+      }
+    };
+  }
+  if (action.runHTTPRequest) {
+    return {
+      requestId,
+      toolName: "gitlab_api_request",
+      args: {
+        method: action.runHTTPRequest.method,
+        path: action.runHTTPRequest.path,
+        body: action.runHTTPRequest.body
+      },
+      responseType: "http"
+    };
+  }
+  return null;
+}
+
+// src/provider/application/runtime.ts
+var GitLabAgenticRuntime = class {
+  #options;
+  #dependencies;
+  #selectedModelIdentifier;
+  #workflowId;
+  #wsClient;
+  #workflowToken;
+  #queue;
+  #stream;
+  #mapper = new WorkflowEventMapper();
+  #containerParams;
+  #startRequestSent = false;
+  constructor(options, dependencies) {
+    this.#options = options;
+    this.#dependencies = dependencies;
+  }
+  // ---------------------------------------------------------------------------
+  // Public accessors
+  // ---------------------------------------------------------------------------
+  get hasStarted() {
+    return this.#startRequestSent;
+  }
+  setSelectedModelIdentifier(ref) {
+    if (ref === this.#selectedModelIdentifier) return;
+    this.#selectedModelIdentifier = ref;
+    this.#resetStreamState();
+  }
+  resetMapperState() {
+    this.#mapper.resetStreamState();
+  }
+  // ---------------------------------------------------------------------------
+  // Connection lifecycle
+  // ---------------------------------------------------------------------------
+  async ensureConnected(goal, workflowType) {
+    if (this.#stream && this.#workflowId && this.#queue) {
+      return;
+    }
+    if (!this.#containerParams) {
+      this.#containerParams = await this.#resolveContainerParams();
+    }
+    if (!this.#workflowId) {
+      this.#workflowId = await this.#createWorkflow(goal, workflowType);
+    }
+    const token = await this.#dependencies.workflowService.getWorkflowToken(
+      this.#options.instanceUrl,
+      this.#options.apiKey,
+      workflowType
+    );
+    this.#workflowToken = token;
+    const MAX_LOCK_RETRIES = 3;
+    const LOCK_RETRY_DELAY_MS = 3e3;
+    for (let attempt = 1; attempt <= MAX_LOCK_RETRIES; attempt++) {
+      this.#queue = new AsyncQueue();
+      try {
+        await this.#connectWebSocket();
+        return;
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
+        if ((msg.includes("1013") || msg.includes("lock")) && attempt < MAX_LOCK_RETRIES) {
+          this.#resetStreamState();
+          await this.#dependencies.clock.sleep(LOCK_RETRY_DELAY_MS);
+          const retryToken = await this.#dependencies.workflowService.getWorkflowToken(
+            this.#options.instanceUrl,
+            this.#options.apiKey,
+            workflowType
+          );
+          this.#workflowToken = retryToken;
+          continue;
+        }
+        if (msg.includes("1013") || msg.includes("lock")) {
+          throw new Error("GitLab Duo workflow is locked (another session may still be active). Please try again in a few seconds.");
+        }
+        throw new Error(`GitLab Duo connection failed: ${msg}`);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Messaging
+  // ---------------------------------------------------------------------------
+  sendStartRequest(goal, workflowType, mcpTools = [], preapprovedTools = [], extraContext = []) {
+    if (!this.#stream || !this.#workflowId) throw new Error("Workflow client not initialized");
+    const additionalContext = this.#options.sendSystemContext === false ? [] : this.#dependencies.systemContext.getSystemContextItems(this.#options.systemRules);
+    additionalContext.push(...extraContext);
+    const startRequest = {
+      startRequest: {
+        workflowID: this.#workflowId,
+        clientVersion: "1.0",
+        workflowDefinition: workflowType,
+        goal,
+        workflowMetadata: JSON.stringify({
+          project_id: this.#containerParams?.projectId,
+          namespace_id: this.#containerParams?.namespaceId
+        }),
+        additional_context: additionalContext.map((context) => ({
+          ...context,
+          metadata: context.metadata ? JSON.stringify(context.metadata) : void 0
+        })),
+        clientCapabilities: ["shell_command"],
+        mcpTools,
+        preapproved_tools: preapprovedTools
+      }
+    };
+    this.#stream.write(startRequest);
+    this.#startRequestSent = true;
+  }
+  sendToolResponse(requestId, response, responseType) {
+    if (!this.#stream) throw new Error("Workflow client not initialized");
+    if (responseType === "http") {
+      const parsed = parseHttpToolOutput(response.output);
+      const event2 = {
+        actionResponse: {
+          requestID: requestId,
+          httpResponse: {
+            status: parsed.status,
+            headers: parsed.headers,
+            response: parsed.body,
+            error: response.error ?? ""
+          }
+        }
+      };
+      this.#stream.write(event2);
+      return;
+    }
+    const event = {
+      actionResponse: {
+        requestID: requestId,
+        plainTextResponse: {
+          response: response.output,
+          error: response.error ?? ""
+        }
+      }
+    };
+    this.#stream.write(event);
+  }
+  getEventStream() {
+    if (!this.#queue) throw new Error("Workflow stream not initialized");
+    return this.#queue.iterate();
+  }
+  // ---------------------------------------------------------------------------
+  // Private: project / workflow resolution
+  // ---------------------------------------------------------------------------
+  async #resolveContainerParams() {
+    const projectPath = await this.#dependencies.projectLookup.detectProjectPath(
+      process.cwd(),
+      this.#options.instanceUrl
+    );
+    if (!projectPath) {
+      throw new Error(
+        "Unable to detect GitLab project. Ensure you run OpenCode in a Git repository with a GitLab remote."
+      );
+    }
+    try {
+      const details = await this.#dependencies.projectLookup.fetchProjectDetailsWithFallback(
+        this.#options.instanceUrl,
+        this.#options.apiKey,
+        projectPath
+      );
+      return {
+        projectId: details.projectId,
+        namespaceId: details.namespaceId
+      };
+    } catch {
+      throw new Error(
+        "Failed to fetch GitLab project details. Check that the remote URL is correct and the token has access."
+      );
+    }
+  }
+  async #createWorkflow(goal, workflowType) {
+    try {
+      return await this.#dependencies.workflowService.createWorkflow(
+        this.#options.instanceUrl,
+        this.#options.apiKey,
+        goal,
+        workflowType,
+        this.#containerParams
+      );
+    } catch (error) {
+      if (isWorkflowCreateError(error) && error.status === 400 && error.body.includes("No default namespace found")) {
+        throw new Error(
+          "No default namespace found. Ensure this repository has a GitLab remote so the namespace can be detected."
+        );
+      }
+      throw error;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private: WebSocket stream binding
+  // ---------------------------------------------------------------------------
+  #bindStream(stream, queue) {
+    const now = () => this.#dependencies.clock.now();
+    const closeWithError = (message) => {
+      queue.push({ type: "ERROR", message, timestamp: now() });
+      queue.close();
+      this.#resetStreamState();
+    };
+    const handleAction = async (action) => {
+      if (action.newCheckpoint) {
+        const duoEvent = {
+          checkpoint: action.newCheckpoint.checkpoint,
+          errors: action.newCheckpoint.errors || [],
+          workflowGoal: action.newCheckpoint.goal,
+          workflowStatus: action.newCheckpoint.status
+        };
+        const events = await this.#mapper.mapWorkflowEvent(duoEvent);
+        for (const event of events) {
+          queue.push(event);
+        }
+        return;
+      }
+      const toolRequest = mapWorkflowActionToToolRequest(action);
+      if (toolRequest) {
+        queue.push({
+          type: "TOOL_REQUEST",
+          ...toolRequest,
+          timestamp: now()
+        });
+        return;
+      }
+    };
+    stream.on("data", (action) => {
+      void handleAction(action).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        closeWithError(message);
+      });
+    });
+    stream.on("error", (err2) => {
+      closeWithError(err2.message);
+    });
+    stream.on("end", () => {
+      queue.close();
+      this.#resetStreamState();
+    });
+  }
+  async #connectWebSocket() {
+    if (!this.#queue) return;
+    if (!this.#workflowToken) throw new Error("Workflow token unavailable");
+    this.#wsClient = this.#dependencies.createWorkflowClient({
+      gitlabInstanceUrl: new URL(this.#options.instanceUrl),
+      token: this.#options.apiKey,
+      headers: buildWorkflowHeaders(
+        this.#workflowToken.duo_workflow_service.headers,
+        this.#containerParams
+      ),
+      selectedModelIdentifier: this.#selectedModelIdentifier
+    });
+    const stream = await this.#wsClient.executeWorkflow();
+    this.#stream = stream;
+    this.#bindStream(stream, this.#queue);
+  }
+  #resetStreamState() {
+    this.#stream = void 0;
+    this.#queue = void 0;
+    this.#startRequestSent = false;
+    this.#wsClient?.dispose();
+    this.#wsClient = void 0;
+  }
+};
+function buildWorkflowHeaders(headers, containerParams) {
+  const result = normalizeHeaders(headers);
+  if (containerParams?.projectId) {
+    result["x-gitlab-project-id"] = containerParams.projectId;
+  }
+  if (containerParams?.namespaceId) {
+    result["x-gitlab-namespace-id"] = containerParams.namespaceId;
+  }
+  const featureSetting = process.env.GITLAB_AGENT_PLATFORM_FEATURE_SETTING_NAME;
+  if (featureSetting) {
+    result["x-gitlab-agent-platform-feature-setting-name"] = featureSetting;
+  }
+  return result;
+}
+function normalizeHeaders(headers) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers || {})) {
+    normalized[key.toLowerCase()] = value;
+  }
+  return normalized;
+}
+function isWorkflowCreateError(error) {
+  if (!error || typeof error !== "object") return false;
+  const value = error;
+  return typeof value.status === "number" && typeof value.body === "string";
+}
+function parseHttpToolOutput(output) {
+  const lines = output.trimEnd().split("\n");
+  const lastLine = lines[lines.length - 1]?.trim() ?? "";
+  const statusCode = parseInt(lastLine, 10);
+  if (!Number.isNaN(statusCode) && statusCode >= 100 && statusCode < 600) {
+    return {
+      status: statusCode,
+      headers: {},
+      body: lines.slice(0, -1).join("\n")
+    };
+  }
+  return { status: 0, headers: {}, body: output };
+}
+
+// src/provider/adapters/default_runtime_dependencies.ts
+import { ProxyAgent } from "proxy-agent";
+
+// src/provider/adapters/gitlab_utils.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+async function detectProjectPath(cwd, instanceUrl) {
+  let current = cwd;
+  const instance = new URL(instanceUrl);
+  const instanceHost = instance.host;
+  const instanceBasePath = instance.pathname.replace(/\/$/, "");
+  while (true) {
+    try {
+      const config = await readGitConfig(current);
+      const url = extractGitRemoteUrl(config) || "";
+      const remote = parseRemote(url);
+      if (!remote) {
+        return void 0;
+      }
+      if (remote.host !== instanceHost) {
+        throw new Error(
+          `GitLab remote host mismatch. Expected ${instanceHost}, got ${remote.host}.`
+        );
+      }
+      return normalizeProjectPath(remote.path, instanceBasePath);
+    } catch {
+      const parent = path4.dirname(current);
+      if (parent === current) return void 0;
+      current = parent;
+    }
+  }
+}
+function extractGitRemoteUrl(config) {
+  const lines = config.split("\n");
+  let inOrigin = false;
+  let originUrl;
+  let firstUrl;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const sectionMatch = /^\[remote\s+"([^"]+)"\]$/.exec(trimmed);
+    if (sectionMatch) {
+      inOrigin = sectionMatch[1] === "origin";
+      continue;
+    }
+    const urlMatch = /^url\s*=\s*(.+)$/.exec(trimmed);
+    if (urlMatch) {
+      const value = urlMatch[1].trim();
+      if (!firstUrl) firstUrl = value;
+      if (inOrigin) originUrl = value;
+    }
+  }
+  return originUrl ?? firstUrl;
+}
+function parseRemote(remoteUrl) {
+  if (!remoteUrl) return void 0;
+  if (remoteUrl.startsWith("http")) {
+    try {
+      const url = new URL(remoteUrl);
+      return { host: url.host, path: url.pathname.replace(/^\//, "") };
+    } catch {
+      return void 0;
+    }
+  }
+  if (remoteUrl.startsWith("git@")) {
+    const match = /^git@([^:]+):(.+)$/.exec(remoteUrl);
+    if (!match) return void 0;
+    return { host: match[1], path: match[2] };
+  }
+  if (remoteUrl.startsWith("ssh://")) {
+    try {
+      const url = new URL(remoteUrl);
+      return { host: url.host, path: url.pathname.replace(/^\//, "") };
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function normalizeProjectPath(remotePath, instanceBasePath) {
+  let pathValue = remotePath;
+  if (instanceBasePath && instanceBasePath !== "/") {
+    const base = instanceBasePath.replace(/^\//, "") + "/";
+    if (pathValue.startsWith(base)) {
+      pathValue = pathValue.slice(base.length);
+    }
+  }
+  const cleaned = stripGitSuffix(pathValue);
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function stripGitSuffix(pathname) {
+  return pathname.endsWith(".git") ? pathname.slice(0, -4) : pathname;
+}
+function buildApiUrl(instanceUrl, apiPath) {
+  const base = instanceUrl.endsWith("/") ? instanceUrl : `${instanceUrl}/`;
+  return new URL(apiPath.replace(/^\//, ""), base).toString();
+}
+function buildAuthHeaders(apiKey) {
+  return { authorization: `Bearer ${apiKey}` };
+}
+async function fetchProjectDetails(instanceUrl, apiKey, projectPath) {
+  const url = buildApiUrl(instanceUrl, `api/v4/projects/${encodeURIComponent(projectPath)}`);
+  const response = await fetch(url, {
+    headers: buildAuthHeaders(apiKey)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch project details: ${response.status}`);
+  }
+  const data = await response.json();
+  return {
+    projectId: data.id ? String(data.id) : void 0,
+    namespaceId: data.namespace?.id ? String(data.namespace.id) : void 0
+  };
+}
+async function fetchProjectDetailsWithFallback(instanceUrl, apiKey, projectPath) {
+  const candidates = getProjectPathCandidates(projectPath);
+  for (const candidate of candidates) {
+    try {
+      return await fetchProjectDetails(instanceUrl, apiKey, candidate);
+    } catch {
+      continue;
+    }
+  }
+  try {
+    const name = projectPath.split("/").pop() || projectPath;
+    const searchUrl = new URL(buildApiUrl(instanceUrl, "api/v4/projects"));
+    searchUrl.searchParams.set("search", name);
+    searchUrl.searchParams.set("simple", "true");
+    searchUrl.searchParams.set("per_page", "100");
+    searchUrl.searchParams.set("membership", "true");
+    const response = await fetch(searchUrl.toString(), {
+      headers: buildAuthHeaders(apiKey)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to search projects: ${response.status}`);
+    }
+    const data = await response.json();
+    const match = data.find((project) => project.path_with_namespace === projectPath);
+    if (!match) {
+      throw new Error("Project not found via search");
+    }
+    return {
+      projectId: match.id ? String(match.id) : void 0,
+      namespaceId: match.namespace?.id ? String(match.namespace.id) : void 0
+    };
+  } catch {
+    throw new Error("Project not found via API");
+  }
+}
+function getProjectPathCandidates(projectPath) {
+  const candidates = /* @__PURE__ */ new Set();
+  candidates.add(projectPath);
+  const parts = projectPath.split("/");
+  if (parts.length > 2) {
+    const withoutFirst = parts.slice(1).join("/");
+    candidates.add(withoutFirst);
+  }
+  return Array.from(candidates);
+}
+async function readGitConfig(cwd) {
+  const gitPath = path4.join(cwd, ".git");
+  const stat = await fs4.stat(gitPath);
+  if (stat.isDirectory()) {
+    return fs4.readFile(path4.join(gitPath, "config"), "utf8");
+  }
+  const file = await fs4.readFile(gitPath, "utf8");
+  const match = /^gitdir:\s*(.+)$/m.exec(file);
+  if (!match) throw new Error("Invalid .git file");
+  const gitdir = match[1].trim();
+  const resolved = path4.isAbsolute(gitdir) ? gitdir : path4.join(cwd, gitdir);
+  return fs4.readFile(path4.join(resolved, "config"), "utf8");
+}
+
+// src/provider/adapters/workflow_service.ts
+var WorkflowCreateError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`Failed to create workflow: ${status} ${body}`);
+    this.status = status;
+    this.body = body;
+  }
+};
+async function createWorkflow(instanceUrl, apiKey, goal, workflowDefinition, containerParams) {
+  const url = buildApiUrl(instanceUrl, "/api/v4/ai/duo_workflows/workflows");
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...buildAuthHeaders(apiKey)
+    },
+    body: JSON.stringify({
+      project_id: containerParams?.projectId,
+      namespace_id: containerParams?.namespaceId,
+      goal,
+      workflow_definition: workflowDefinition,
+      environment: "ide",
+      allow_agent_to_request_user: true
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new WorkflowCreateError(response.status, text);
+  }
+  const data = await response.json();
+  if (!data.id) {
+    throw new Error(`Workflow creation failed: ${data.error || data.message || "unknown"}`);
+  }
+  return data.id.toString();
+}
+async function getWorkflowToken(instanceUrl, apiKey, workflowDefinition) {
+  const url = buildApiUrl(instanceUrl, "/api/v4/ai/duo_workflows/direct_access");
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...buildAuthHeaders(apiKey)
+    },
+    body: JSON.stringify({ workflow_definition: workflowDefinition })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to fetch workflow token: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+
+// src/provider/adapters/workflow_client.ts
+import WebSocket2 from "isomorphic-ws";
+import { v4 as uuid4 } from "uuid";
+
+// src/provider/adapters/websocket_stream.ts
+import WebSocket from "isomorphic-ws";
+import { EventEmitter } from "events";
+var KEEPALIVE_PING_INTERVAL_MS = 45 * 1e3;
+var WebSocketWorkflowStream = class extends EventEmitter {
+  #socket;
+  #keepalivePingIntervalId;
+  constructor(socket) {
+    super();
+    this.#socket = socket;
+    this.#setupEventHandlers();
+  }
+  #setupEventHandlers() {
+    this.#socket.on("message", (event) => {
+      try {
+        const data = event && typeof event === "object" && "data" in event ? event.data : event;
+        let message;
+        if (typeof data === "string") {
+          message = data;
+        } else if (Buffer.isBuffer(data)) {
+          message = data.toString("utf8");
+        } else if (data instanceof ArrayBuffer) {
+          message = Buffer.from(data).toString("utf8");
+        } else if (Array.isArray(data)) {
+          message = Buffer.concat(data).toString("utf8");
+        } else {
+          return;
+        }
+        if (!message || message === "undefined") {
+          return;
+        }
+        const parsed = JSON.parse(message);
+        this.emit("data", parsed);
+      } catch (err2) {
+        this.emit("error", err2 instanceof Error ? err2 : new Error(String(err2)));
+      }
+    });
+    this.#socket.on("open", () => {
+      this.emit("open");
+    });
+    this.#socket.on("error", (event) => {
+      if (event instanceof Error) {
+        this.emit("error", event);
+        return;
+      }
+      const serialized = safeStringifyErrorEvent(event);
+      this.emit("error", new Error(serialized));
+    });
+    this.#socket.on("close", (code, reason) => {
+      clearInterval(this.#keepalivePingIntervalId);
+      if (code === 1e3) {
+        this.emit("end");
+        return;
+      }
+      const reasonString = reason?.toString("utf8");
+      this.emit("error", new Error(`WebSocket closed abnormally: ${code} ${reasonString || ""}`));
+    });
+    this.#socket.on("pong", () => {
+    });
+    this.#startKeepalivePingInterval();
+  }
+  #startKeepalivePingInterval() {
+    this.#keepalivePingIntervalId = setInterval(() => {
+      if (this.#socket.readyState !== WebSocket.OPEN) return;
+      const timestamp = Date.now().toString();
+      this.#socket.ping(Buffer.from(timestamp), void 0, () => {
+      });
+    }, KEEPALIVE_PING_INTERVAL_MS);
+  }
+  write(data) {
+    if (this.#socket.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    this.#socket.send(JSON.stringify(data));
+    return true;
+  }
+  end() {
+    this.#socket.close(1e3);
+  }
+};
+function safeStringifyErrorEvent(event) {
+  const payload = {
+    type: event.type,
+    message: event.message,
+    error: event.error ? String(event.error) : void 0,
+    target: {
+      readyState: event.target?.readyState,
+      url: event.target?.url
+    }
+  };
+  return JSON.stringify(payload);
+}
+
+// src/provider/adapters/workflow_client.ts
+var WebSocketWorkflowClient = class {
+  #connectionDetails;
+  #selectedModelIdentifier;
+  #socket = null;
+  #stream = null;
+  #correlationId = uuid4();
+  constructor(connectionDetails) {
+    this.#connectionDetails = connectionDetails;
+    this.#selectedModelIdentifier = connectionDetails.selectedModelIdentifier;
+  }
+  async executeWorkflow() {
+    const url = this.#buildWebSocketUrl();
+    const headers = this.#createConnectionHeaders();
+    const clientOptions = { headers };
+    if (this.#connectionDetails.agent) {
+      Object.assign(clientOptions, { agent: this.#connectionDetails.agent });
+    }
+    this.#socket = new WebSocket2(url, clientOptions);
+    this.#stream = new WebSocketWorkflowStream(this.#socket);
+    await new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error("WebSocket connection timeout"));
+      }, 15e3);
+      const onOpen = () => {
+        clearTimeout(timeoutId);
+        this.#stream?.removeListener("error", onError);
+        resolve();
+      };
+      const onError = (err2) => {
+        clearTimeout(timeoutId);
+        this.#stream?.removeListener("open", onOpen);
+        reject(err2);
+      };
+      this.#stream?.once("open", onOpen);
+      this.#stream?.once("error", onError);
+    });
+    return this.#stream;
+  }
+  dispose() {
+    this.#stream?.end();
+    this.#stream = null;
+    this.#socket = null;
+  }
+  #buildWebSocketUrl() {
+    const baseUrl = new URL(this.#connectionDetails.gitlabInstanceUrl);
+    const basePath = baseUrl.pathname.endsWith("/") ? baseUrl.pathname : `${baseUrl.pathname}/`;
+    const url = new URL(basePath + "api/v4/ai/duo_workflows/ws", baseUrl);
+    url.protocol = baseUrl.protocol === "https:" ? "wss:" : "ws:";
+    if (this.#selectedModelIdentifier) {
+      url.searchParams.set("user_selected_model_identifier", this.#selectedModelIdentifier);
+    }
+    return url.toString();
+  }
+  #createConnectionHeaders() {
+    const headers = { ...this.#connectionDetails.headers };
+    headers["authorization"] = `Bearer ${this.#connectionDetails.token}`;
+    headers["x-request-id"] = this.#correlationId;
+    headers["x-gitlab-language-server-version"] = LANGUAGE_SERVER_VERSION;
+    headers["x-gitlab-client-type"] = "node-websocket";
+    headers["user-agent"] = buildUserAgent();
+    headers["origin"] = this.#connectionDetails.gitlabInstanceUrl.origin;
+    return headers;
+  }
+};
+var LANGUAGE_SERVER_VERSION = "8.62.2";
+function buildUserAgent() {
+  return `unknown/unknown unknown/unknown gitlab-language-server/${LANGUAGE_SERVER_VERSION}`;
+}
+
+// src/provider/adapters/system_context.ts
+import os from "os";
+function getSystemContextItems(systemRules) {
+  const platform = os.platform();
+  const arch = os.arch();
+  const items = [
+    {
+      category: "os_information",
+      content: `<os><platform>${platform}</platform><architecture>${arch}</architecture></os>`,
+      id: "os_information",
+      metadata: {
+        title: "Operating System",
+        enabled: true,
+        subType: "os",
+        icon: "monitor",
+        secondaryText: `${platform} ${arch}`,
+        subTypeLabel: "System Information"
+      }
+    }
+  ];
+  const trimmedRules = systemRules?.trim();
+  const combinedRules = trimmedRules ? `${trimmedRules}
+
+${SYSTEM_RULES}` : SYSTEM_RULES;
+  if (combinedRules.trim()) {
+    items.push({
+      category: "user_rule",
+      content: combinedRules,
+      id: "user_rules",
+      metadata: {
+        title: "System Rules",
+        enabled: true,
+        subType: "user_rule",
+        icon: "file-text",
+        secondaryText: "User rules",
+        subTypeLabel: "System rules"
+      }
+    });
+  }
+  return items;
+}
+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.
+- Temporary rule: do NOT use read_files; use read_file only (repeat calls as needed).
+
+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/application/di_container.ts
+var DIContainer = class {
+  #registrations = /* @__PURE__ */ new Map();
+  #resolving = /* @__PURE__ */ new Set();
+  registerSingleton(token, factory) {
+    this.#registrations.set(token, {
+      scope: "singleton",
+      factory,
+      initialized: false
+    });
+  }
+  registerTransient(token, factory) {
+    this.#registrations.set(token, {
+      scope: "transient",
+      factory,
+      initialized: false
+    });
+  }
+  resolve(token) {
+    const registration = this.#registrations.get(token);
+    if (!registration) {
+      throw new Error(`Missing DI registration for token: ${token}`);
+    }
+    if (registration.scope === "singleton") {
+      if (!registration.initialized) {
+        registration.instance = this.#build(token, registration.factory);
+        registration.initialized = true;
+      }
+      return registration.instance;
+    }
+    return this.#build(token, registration.factory);
+  }
+  #build(token, factory) {
+    if (this.#resolving.has(token)) {
+      throw new Error(`Circular DI dependency detected for token: ${token}`);
+    }
+    this.#resolving.add(token);
+    try {
+      return factory(this);
+    } finally {
+      this.#resolving.delete(token);
+    }
+  }
+};
+
+// src/provider/adapters/default_runtime_dependencies.ts
+var RUNTIME_TOKENS = {
+  workflowService: "runtime.workflowService",
+  workflowClientFactory: "runtime.workflowClientFactory",
+  projectLookup: "runtime.projectLookup",
+  systemContext: "runtime.systemContext",
+  clock: "runtime.clock",
+  runtimeDependencies: "runtime.dependencies"
+};
+function createRuntimeContainer() {
+  const container = new DIContainer();
+  registerDefaultRuntimeDependencies(container);
+  return container;
+}
+function registerDefaultRuntimeDependencies(container) {
+  container.registerSingleton(
+    RUNTIME_TOKENS.workflowService,
+    () => ({
+      createWorkflow,
+      getWorkflowToken
+    })
+  );
+  container.registerSingleton(
+    RUNTIME_TOKENS.workflowClientFactory,
+    () => ((config) => new WebSocketWorkflowClient({
+      ...config,
+      ...resolveWorkflowClientOptions()
+    }))
+  );
+  container.registerSingleton(
+    RUNTIME_TOKENS.projectLookup,
+    () => ({
+      detectProjectPath,
+      fetchProjectDetailsWithFallback
+    })
+  );
+  container.registerSingleton(
+    RUNTIME_TOKENS.systemContext,
+    () => ({
+      getSystemContextItems
+    })
+  );
+  container.registerSingleton(
+    RUNTIME_TOKENS.clock,
+    () => ({
+      now: () => Date.now(),
+      sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+    })
+  );
+  container.registerSingleton(
+    RUNTIME_TOKENS.runtimeDependencies,
+    (c) => ({
+      workflowService: c.resolve(
+        RUNTIME_TOKENS.workflowService
+      ),
+      createWorkflowClient: c.resolve(
+        RUNTIME_TOKENS.workflowClientFactory
+      ),
+      projectLookup: c.resolve(
+        RUNTIME_TOKENS.projectLookup
+      ),
+      systemContext: c.resolve(
+        RUNTIME_TOKENS.systemContext
+      ),
+      clock: c.resolve(RUNTIME_TOKENS.clock)
+    })
+  );
+}
+function resolveWorkflowClientOptions() {
+  if (process.env.HTTPS_PROXY || process.env.HTTP_PROXY) {
+    return { agent: new ProxyAgent() };
+  }
+  return {};
+}
+
+// src/provider/interfaces/provider.ts
+import { createRequire as createRequire2 } from "module";
+var REQUIRED_MODULES = [
+  "isomorphic-ws",
+  "uuid",
+  "zod",
+  "neverthrow",
+  "proxy-agent"
+];
+function assertDependencies() {
+  const require2 = createRequire2(import.meta.url);
+  const missing = [];
+  for (const name of REQUIRED_MODULES) {
+    try {
+      require2.resolve(name);
+    } catch {
+      missing.push(name);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      "Missing provider dependencies: " + missing.join(", ") + ". Run `npm install` in the package directory."
+    );
+  }
+}
+function assertInstanceUrl(value) {
+  try {
+    new URL(value);
+  } catch {
+    throw new Error(`Invalid instanceUrl: "${value}"`);
+  }
+}
+function createGitLabDuoAgentic(options) {
+  assertDependencies();
+  assertInstanceUrl(options.instanceUrl);
+  const container = createRuntimeContainer();
+  const dependencies = container.resolve(
+    RUNTIME_TOKENS.runtimeDependencies
+  );
+  const sharedRuntime = new GitLabAgenticRuntime(options, dependencies);
+  return {
+    languageModel(modelId) {
+      return new GitLabDuoAgenticLanguageModel(modelId, options, sharedRuntime);
+    },
+    textEmbeddingModel() {
+      throw new Error("GitLab Duo Agentic does not support text embedding models");
+    },
+    imageModel() {
+      throw new Error("GitLab Duo Agentic does not support image models");
+    }
+  };
+}
+export {
+  GitLabDuoAgenticPlugin,
+  createGitLabDuoAgentic,
+  GitLabDuoAgenticPlugin as default
+};