opencode-gitlab-duo-agentic 0.1.7 → 0.1.8

package/dist/index.js

@@ -1,2715 +1,7 @@
-// src/plugin/config.ts
-import path4 from "path";
-import fs4 from "fs";
-
-// src/plugin/models.ts
-import path3 from "path";
-import fs3 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/fetch_models.ts
-import crypto from "crypto";
-import os from "os";
-import path2 from "path";
-import fs2 from "fs/promises";
-
-// src/provider/adapters/gitlab_utils.ts
-import fs from "fs/promises";
-import path 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 = path.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 = path.join(cwd, ".git");
-  const stat = await fs.stat(gitPath);
-  if (stat.isDirectory()) {
-    return fs.readFile(path.join(gitPath, "config"), "utf8");
-  }
-  const file = await fs.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 = path.isAbsolute(gitdir) ? gitdir : path.join(cwd, gitdir);
-  return fs.readFile(path.join(resolved, "config"), "utf8");
-}
-async function resolveRootNamespaceId(instanceUrl, apiKey, namespaceId) {
-  let currentId = namespaceId;
-  for (let depth = 0; depth < 20; depth++) {
-    const url = buildApiUrl(instanceUrl, `api/v4/namespaces/${currentId}`);
-    const response = await fetch(url, {
-      headers: buildAuthHeaders(apiKey)
-    });
-    if (!response.ok) {
-      break;
-    }
-    const data = await response.json();
-    if (!data.parent_id) {
-      currentId = String(data.id ?? currentId);
-      break;
-    }
-    currentId = String(data.parent_id);
-  }
-  return `gid://gitlab/Group/${currentId}`;
-}
-
-// src/plugin/fetch_models.ts
-var DEFAULT_MODELS_CACHE_TTL_SECONDS = 60 * 60 * 24;
-var AVAILABLE_MODELS_QUERY = `query lsp_aiChatAvailableModels($rootNamespaceId: GroupID!) {
-  metadata {
-    featureFlags(names: ["ai_user_model_switching"]) {
-      enabled
-      name
-    }
-    version
-  }
-  aiChatAvailableModels(rootNamespaceId: $rootNamespaceId) {
-    defaultModel { name ref }
-    selectableModels { name ref }
-    pinnedModel { name ref }
-  }
-}`;
-function resolveModelsCacheTtlSeconds() {
-  const raw = process.env.GITLAB_DUO_MODELS_CACHE_TTL;
-  if (!raw) return DEFAULT_MODELS_CACHE_TTL_SECONDS;
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed < 0) {
-    return DEFAULT_MODELS_CACHE_TTL_SECONDS;
-  }
-  return parsed;
-}
-async function loadModelsFromCache(options) {
-  const instanceUrl = normalizeInstanceUrl(options.instanceUrl);
-  const cwd = options.cwd ?? process.cwd();
-  const ttlSeconds = options.ttlSeconds ?? resolveModelsCacheTtlSeconds();
-  const allowStale = options.allowStale ?? false;
-  const { cachePath, projectPath } = await resolveCacheLocation(instanceUrl, cwd);
-  let raw;
-  try {
-    raw = await fs2.readFile(cachePath, "utf8");
-  } catch (error) {
-    const fsError = error;
-    if (fsError?.code === "ENOENT") return null;
-    console.warn(
-      `[gitlab-duo] Failed to read models cache at ${cachePath}: ${fsError?.message ?? String(error)}`
-    );
-    return null;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    console.warn(
-      `[gitlab-duo] Failed to parse models cache at ${cachePath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return null;
-  }
-  const models = parsed.payload?.models;
-  if (!models || Object.keys(models).length === 0) return null;
-  const cachedAtMs = Date.parse(parsed.cachedAt);
-  const ageSeconds = Number.isFinite(cachedAtMs) ? Math.max(0, (Date.now() - cachedAtMs) / 1e3) : Infinity;
-  const stale = ageSeconds > ttlSeconds;
-  if (stale && !allowStale) return null;
-  return {
-    payload: parsed.payload,
-    stale,
-    cachePath,
-    projectPath
-  };
-}
-async function fetchAndCacheModels(options) {
-  const instanceUrl = normalizeInstanceUrl(options.instanceUrl);
-  const apiKey = options.apiKey.trim();
-  const cwd = options.cwd ?? process.cwd();
-  if (!apiKey) {
-    throw new Error("GITLAB_TOKEN is required for live model discovery");
-  }
-  const projectPath = await resolveProjectPath(cwd, instanceUrl);
-  if (!projectPath) {
-    throw new Error("Could not detect GitLab project from git remote");
-  }
-  const payload = await fetchModels(instanceUrl, apiKey, projectPath);
-  const { cachePath } = await resolveCacheLocation(instanceUrl, cwd, projectPath);
-  await writeCache(cachePath, payload);
-  return {
-    payload,
-    stale: false,
-    cachePath,
-    projectPath
-  };
-}
-async function fetchModels(instanceUrl, apiKey, projectPath) {
-  const details = await fetchProjectDetailsWithFallback(instanceUrl, apiKey, projectPath);
-  const namespaceId = details.namespaceId;
-  if (!namespaceId) {
-    throw new Error("Could not determine namespace ID from project");
-  }
-  const rootNamespaceId = await resolveRootNamespaceId(instanceUrl, apiKey, namespaceId);
-  const graphqlUrl = `${instanceUrl}/api/graphql`;
-  const response = await fetch(graphqlUrl, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify({
-      query: AVAILABLE_MODELS_QUERY,
-      variables: { rootNamespaceId }
-    })
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`GraphQL request failed (${response.status}): ${text}`);
-  }
-  const result = await response.json();
-  if (result.errors?.length) {
-    throw new Error(result.errors.map((error) => error.message).join("; "));
-  }
-  const metadata = result.data?.metadata;
-  const available = result.data?.aiChatAvailableModels;
-  const defaultModel = available?.defaultModel ?? null;
-  const pinnedModel = available?.pinnedModel ?? null;
-  const selectableModels = available?.selectableModels ?? [];
-  const featureFlags = {};
-  for (const flag of metadata?.featureFlags ?? []) {
-    featureFlags[flag.name] = flag.enabled;
-  }
-  const models = {};
-  if (defaultModel?.ref) {
-    models[defaultModel.ref] = buildModelEntry(defaultModel.name || defaultModel.ref);
-  }
-  if (pinnedModel?.ref) {
-    models[pinnedModel.ref] = buildModelEntry(pinnedModel.name || pinnedModel.ref);
-  }
-  for (const model of selectableModels) {
-    if (model.ref && !models[model.ref]) {
-      models[model.ref] = buildModelEntry(model.name || model.ref);
-    }
-  }
-  if (Object.keys(models).length === 0) {
-    models[GITLAB_DUO_DEFAULT_MODEL_ID] = buildModelEntry(GITLAB_DUO_DEFAULT_MODEL_NAME);
-  }
-  return {
-    metadata: {
-      instanceUrl,
-      rootNamespaceId,
-      gitlabVersion: metadata?.version ?? null,
-      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      featureFlags,
-      defaultModel: defaultModel?.ref ?? null,
-      pinnedModel: pinnedModel?.ref ?? null
-    },
-    models,
-    available: {
-      defaultModel,
-      pinnedModel,
-      selectableModels
-    }
-  };
-}
-async function resolveCacheLocation(instanceUrl, cwd, projectPathHint) {
-  const projectPath = projectPathHint ?? await resolveProjectPath(cwd, instanceUrl);
-  const cacheDir = resolveCacheDirectory();
-  const cacheKey = `${instanceUrl}::${projectPath ?? "no-project"}`;
-  const hash = crypto.createHash("sha256").update(cacheKey).digest("hex").slice(0, 12);
-  return {
-    cachePath: path2.join(cacheDir, `gitlab-duo-models-${hash}.json`),
-    projectPath
-  };
-}
-function resolveCacheDirectory() {
-  const xdg = process.env.XDG_CACHE_HOME?.trim();
-  if (xdg) return path2.join(xdg, "opencode");
-  return path2.join(os.homedir(), ".cache", "opencode");
-}
-async function resolveProjectPath(cwd, instanceUrl) {
-  try {
-    return await detectProjectPath(cwd, instanceUrl);
-  } catch {
-    return void 0;
-  }
-}
-async function writeCache(cachePath, payload) {
-  const data = {
-    cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    payload
-  };
-  await fs2.mkdir(path2.dirname(cachePath), { recursive: true });
-  await fs2.writeFile(cachePath, JSON.stringify(data, null, 2) + "\n", "utf8");
-}
-function normalizeInstanceUrl(value) {
-  return value.trim().replace(/\/$/, "");
-}
-
-// src/plugin/models.ts
-async function loadGitLabModels(options = {}) {
-  const instanceUrl = resolveInstanceUrl(options.instanceUrl);
-  const apiKey = resolveApiKey(options.apiKey);
-  const cacheTtlSeconds = resolveModelsCacheTtlSeconds();
-  const cache = await loadModelsFromCache({
-    instanceUrl,
-    ttlSeconds: cacheTtlSeconds,
-    allowStale: true
-  });
-  if (cache && !cache.stale) {
-    console.log(
-      `[gitlab-duo] Loaded ${Object.keys(cache.payload.models).length} model(s) from cache ${cache.cachePath}`
-    );
-    return cache.payload.models;
-  }
-  if (apiKey) {
-    try {
-      const fetched = await fetchAndCacheModels({
-        instanceUrl,
-        apiKey
-      });
-      console.log(
-        `[gitlab-duo] Loaded ${Object.keys(fetched.payload.models).length} model(s) from GitLab API`
-      );
-      return fetched.payload.models;
-    } catch (error) {
-      console.warn(
-        `[gitlab-duo] Failed to fetch models from GitLab API: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  if (cache?.stale) {
-    console.warn(`[gitlab-duo] Using stale models cache from ${cache.cachePath}`);
-    return cache.payload.models;
-  }
-  const modelsJsonPath = resolveModelsJsonPath(options.modelsPath);
-  const modelsFromFile = await loadModelsFromFile(modelsJsonPath);
-  if (modelsFromFile) return modelsFromFile;
-  return {
-    [GITLAB_DUO_DEFAULT_MODEL_ID]: buildModelEntry(GITLAB_DUO_DEFAULT_MODEL_NAME)
-  };
-}
-async function loadModelsFromFile(modelsJsonPath) {
-  if (modelsJsonPath) {
-    try {
-      const raw = await fs3.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 null;
-}
-function resolveModelsJsonPath(overridePath) {
-  const override = typeof overridePath === "string" && overridePath.trim() ? overridePath.trim() : process.env.GITLAB_DUO_MODELS_PATH;
-  if (override) {
-    const resolved = path3.isAbsolute(override) ? override : path3.resolve(process.cwd(), override);
-    if (fs3.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 = path3.join(current, "models.json");
-    if (fs3.existsSync(candidate)) return candidate;
-    const parent = path3.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return null;
-}
-function resolveInstanceUrl(override) {
-  if (typeof override === "string" && override.trim()) return override.trim();
-  const fromEnv = process.env.GITLAB_INSTANCE_URL?.trim();
-  if (fromEnv) return fromEnv.replace(/\/$/, "");
-  return "https://gitlab.com";
-}
-function resolveApiKey(override) {
-  if (typeof override === "string" && override.trim()) return override.trim();
-  return process.env.GITLAB_TOKEN || "";
-}
-
-// 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.trim() ? existingOptions.apiKey.trim() : process.env.GITLAB_TOKEN || "";
-  const instanceUrl = typeof existingOptions.instanceUrl === "string" && existingOptions.instanceUrl.trim() ? existingOptions.instanceUrl.trim() : process.env.GITLAB_INSTANCE_URL?.trim() || "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, instanceUrl, apiKey })
-  };
-}
-async function mergeSystemRules(rules, rulesPath) {
-  const baseRules = rules.trim();
-  if (!rulesPath) return baseRules;
-  const resolvedPath = path4.isAbsolute(rulesPath) ? rulesPath : path4.resolve(process.cwd(), rulesPath);
-  try {
-    const fileRules = (await fs4.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 path5 from "path";
-import fs5 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 fs5.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 fs5.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 = path5.isAbsolute(filePath) ? filePath : path5.resolve(ctx.worktree, filePath);
-  const worktreePath = path5.resolve(ctx.worktree);
-  if (resolvedPath !== worktreePath && !resolvedPath.startsWith(worktreePath + path5.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/core/debug_log.ts
-import { appendFileSync } from "fs";
-var LOG_PATH = "/tmp/duo-debug.log";
-function duoLog(...args) {
-  const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
-  const line = ts + " " + args.map(
-    (a) => typeof a === "object" && a !== null ? JSON.stringify(a) : String(a)
-  ).join(" ");
-  try {
-    appendFileSync(LOG_PATH, line + "\n");
-  } catch {
-  }
-}
-
-// src/provider/application/model.ts
-var EMPTY_USAGE = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-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 promptText = extractLastUserText(options.prompt);
-    if (!this.#runtime.tryAcquireStreamLock()) {
-      duoLog("--- doStream BUSY (rejected)", "prompt=" + (promptText?.slice(0, 40) ?? "null"));
-      return { stream: emptyFinishStream() };
-    }
-    const workflowType = "chat";
-    const toolResults = extractToolResults(options.prompt);
-    duoLog("--- doStream", "hasStarted=" + this.#runtime.hasStarted, "prompt=" + (promptText?.slice(0, 60) ?? "null"));
-    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"
-          }
-        });
-      }
-      duoLog("sendStartRequest", "hasStarted=" + this.#runtime.hasStarted);
-      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;
-    let eventCount = 0;
-    yield { type: "stream-start", warnings: [] };
-    try {
-      for await (const event of events) {
-        eventCount++;
-        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) {
-      duoLog("streamErr", streamErr instanceof Error ? streamErr.message : String(streamErr));
-      yield { type: "error", error: streamErr instanceof Error ? streamErr : new Error(String(streamErr)) };
-      return;
-    } finally {
-      this.#runtime.releaseStreamLock();
-    }
-    duoLog("finish", "events=" + eventCount);
-    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 emptyFinishStream() {
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue({ type: "finish", finishReason: "stop", usage: EMPTY_USAGE });
-      controller.close();
-    }
-  });
-}
-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 crypto2 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 || crypto2.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;
-  #streamingLock = 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();
-  }
-  tryAcquireStreamLock() {
-    if (this.#streamingLock) return false;
-    this.#streamingLock = true;
-    return true;
-  }
-  releaseStreamLock() {
-    this.#streamingLock = false;
-  }
-  resetMapperState() {
-    this.#mapper.resetStreamState();
-  }
-  // ---------------------------------------------------------------------------
-  // Connection lifecycle
-  // ---------------------------------------------------------------------------
-  async ensureConnected(goal, workflowType) {
-    duoLog("ensureConnected", "stream=" + !!this.#stream, "wfId=" + !!this.#workflowId, "queue=" + !!this.#queue);
-    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);
-      duoLog("workflow created", this.#workflowId);
-    } else {
-      duoLog("workflow reuse", this.#workflowId);
-    }
-    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();
-        duoLog("ws connected", "attempt=" + attempt);
-        return;
-      } catch (err2) {
-        const msg = err2 instanceof Error ? err2.message : String(err2);
-        duoLog("ws error", msg);
-        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) => {
-      duoLog("streamErr", message);
-      queue.push({ type: "ERROR", message, timestamp: now() });
-      queue.close();
-      this.#resetStreamState();
-    };
-    const handleAction = async (action) => {
-      if (action.newCheckpoint) {
-        duoLog("checkpoint", action.newCheckpoint.status);
-        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) {
-        duoLog("toolReq", toolRequest.toolName);
-        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", () => {
-      duoLog("stream 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() {
-    duoLog("reset", "wf=" + this.#workflowId);
-    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/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 os2 from "os";
-function getSystemContextItems(systemRules) {
-  const platform = os2.platform();
-  const arch = os2.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 resolveInstanceUrl2(value) {
-  if (typeof value === "string" && value.trim()) {
-    const normalized = value.trim();
-    assertInstanceUrl(normalized);
-    return normalized;
-  }
-  const fromEnv = process.env.GITLAB_INSTANCE_URL?.trim();
-  if (fromEnv) {
-    assertInstanceUrl(fromEnv);
-    return fromEnv;
-  }
-  return "https://gitlab.com";
-}
-function assertInstanceUrl(value) {
-  try {
-    new URL(value);
-  } catch {
-    throw new Error(
-      `Invalid instanceUrl: "${value}". Expected an absolute URL (for example https://gitlab.com).`
-    );
-  }
-}
-function resolveApiKey2(value) {
-  if (typeof value === "string" && value.trim()) return value.trim();
-  return process.env.GITLAB_TOKEN || "";
-}
-function createGitLabDuoAgentic(options = {}) {
-  assertDependencies();
-  const resolvedOptions = {
-    instanceUrl: resolveInstanceUrl2(options.instanceUrl),
-    apiKey: resolveApiKey2(options.apiKey),
-    sendSystemContext: typeof options.sendSystemContext === "boolean" ? options.sendSystemContext : true,
-    enableMcp: typeof options.enableMcp === "boolean" ? options.enableMcp : true,
-    systemRules: typeof options.systemRules === "string" ? options.systemRules : void 0
-  };
-  if (!resolvedOptions.apiKey) {
-    console.warn(
-      "[gitlab-duo] GITLAB_TOKEN is empty for the OpenCode process. Ensure it is exported in the same shell."
-    );
-  }
-  const container = createRuntimeContainer();
-  const dependencies = container.resolve(
-    RUNTIME_TOKENS.runtimeDependencies
-  );
-  const sharedRuntime = new GitLabAgenticRuntime(resolvedOptions, dependencies);
-  return {
-    languageModel(modelId) {
-      return new GitLabDuoAgenticLanguageModel(modelId, resolvedOptions, 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");
-    }
-  };
-}
+// src/index.ts
+var GitLabDuoAgenticPlugin = async () => ({});
+var src_default = GitLabDuoAgenticPlugin;
 export {
   GitLabDuoAgenticPlugin,
-  createGitLabDuoAgentic,
-  GitLabDuoAgenticPlugin as default
+  src_default as default
 };