opencode-gitlab-dap 1.4.3 → 1.5.1

package/dist/index.js

@@ -3123,6 +3123,7 @@ components:
     prompt_version: "^1.0.0"
     response_schema_id: "fix_pipeline_decide_approach"
     response_schema_version: "^1.0.0"
+    response_schema_tracking: true
     inputs:
       - from: "context:fix_pipeline_context.final_answer"
         as: "fix_pipeline_context_results"
@@ -3467,6 +3468,7 @@ components:
     prompt_version: "^1.0.0"
     response_schema_id: "fix_pipeline_next_decide_approach"
     response_schema_version: "^1.0.0"
+    response_schema_tracking: true
     inputs:
       - from: "context:fix_pipeline_context.final_answer"
         as: "fix_pipeline_context_results"
@@ -3911,6 +3913,61 @@ async function fetchCustomAgents(instanceUrl, token, projectId) {
   }
   return agents;
 }
+var MCP_SERVERS_QUERY = `
+query AiCatalogMcpServers($projectId: ProjectID!, $after: String) {
+  aiCatalogConfiguredItems(first: 50, projectId: $projectId, itemTypes: [AGENT], after: $after) {
+    pageInfo { hasNextPage endCursor }
+    nodes {
+      item {
+        id
+        name
+        latestVersion {
+          ... on AiCatalogAgentVersion {
+            mcpServers {
+              nodes { id name description url transport authType currentUserConnected }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+async function fetchMcpServers(instanceUrl, token, projectId, agents) {
+  try {
+    let after = null;
+    const serversByAgent = /* @__PURE__ */ new Map();
+    for (; ; ) {
+      const data = await gql(instanceUrl, token, MCP_SERVERS_QUERY, {
+        projectId,
+        ...after ? { after } : {}
+      });
+      const page = data?.aiCatalogConfiguredItems;
+      if (!page) break;
+      for (const node of page.nodes ?? []) {
+        const item = node.item;
+        const version = item?.latestVersion;
+        if (!version?.mcpServers?.nodes?.length) continue;
+        const servers = version.mcpServers.nodes.map((s) => ({
+          id: s.id,
+          name: s.name,
+          description: s.description ?? "",
+          url: s.url,
+          transport: s.transport,
+          authType: s.authType,
+          currentUserConnected: !!s.currentUserConnected
+        }));
+        serversByAgent.set(item.id, servers);
+      }
+      if (!page.pageInfo?.hasNextPage) break;
+      after = page.pageInfo.endCursor;
+    }
+    for (const agent of agents) {
+      const servers = serversByAgent.get(agent.identifier);
+      if (servers?.length) agent.mcpServers = servers;
+    }
+  } catch {
+  }
+}
 async function getFlowDefinition(instanceUrl, token, opts) {
   const name = opts.flowName ?? `consumer-${opts.consumerId}`;
   let config = null;
@@ -4056,7 +4113,9 @@ async function fetchCatalogAgents(instanceUrl, token, projectId) {
       fetchFoundationalChatAgents(instanceUrl, token, projectId),
       fetchCustomAgents(instanceUrl, token, projectId)
     ]);
-    return [...foundational, ...custom];
+    const agents = [...foundational, ...custom];
+    await fetchMcpServers(instanceUrl, token, projectId, agents);
+    return agents;
   } catch {
     return [];
   }
@@ -4195,6 +4254,67 @@ query resolveProjectIds($projectPath: ID!) {
     namespace { id }
   }
 }`;
+var CREATE_AGENT_MUTATION = `
+mutation AiCatalogAgentCreate($input: AiCatalogAgentCreateInput!) {
+  aiCatalogAgentCreate(input: $input) {
+    errors
+    item {
+      id
+      name
+      description
+      itemType
+      public
+      project { id, nameWithNamespace, webUrl }
+      latestVersion {
+        id
+        humanVersionName
+        released
+        ... on AiCatalogAgentVersion {
+          systemPrompt
+          userPrompt
+          tools { nodes { id, name, description } }
+          mcpServers { nodes { id, name, url } }
+        }
+      }
+    }
+  }
+}`;
+var UPDATE_AGENT_MUTATION = `
+mutation AiCatalogAgentUpdate($input: AiCatalogAgentUpdateInput!) {
+  aiCatalogAgentUpdate(input: $input) {
+    errors
+    item {
+      id
+      name
+      description
+      itemType
+      public
+      project { id, nameWithNamespace, webUrl }
+      latestVersion {
+        id
+        humanVersionName
+        released
+        ... on AiCatalogAgentVersion {
+          systemPrompt
+          userPrompt
+          tools { nodes { id, name, description } }
+          mcpServers { nodes { id, name, url } }
+        }
+      }
+    }
+  }
+}`;
+var LIST_BUILTIN_TOOLS_QUERY = `
+query AiCatalogBuiltInTools {
+  aiCatalogBuiltInTools(first: 1000) {
+    nodes {
+      id
+      name
+      title
+      description
+    }
+  }
+}`;
 function normalizeItemGid(id) {
   if (id.startsWith("gid://")) return id;
   if (!/^\d+$/.test(id)) throw new Error(`Invalid catalog item ID: "${id}"`);
@@ -4267,6 +4387,49 @@ async function disableAiCatalogItemForProject(instanceUrl, token, projectPath, i
   }
   return result.aiCatalogItemConsumerDelete;
 }
+async function createAgent(instanceUrl, token, projectPath, params) {
+  const projectGid = await resolveProjectGid(instanceUrl, token, projectPath);
+  const input = {
+    projectId: projectGid,
+    name: params.name,
+    description: params.description,
+    public: params.public,
+    systemPrompt: params.systemPrompt
+  };
+  if (params.userPrompt) input.userPrompt = params.userPrompt;
+  if (params.tools?.length) input.tools = params.tools;
+  if (params.mcpTools?.length) input.mcpTools = params.mcpTools;
+  if (params.mcpServers?.length) input.mcpServers = params.mcpServers;
+  if (params.release !== void 0) input.release = params.release;
+  const result = await gql(instanceUrl, token, CREATE_AGENT_MUTATION, { input });
+  if (result.aiCatalogAgentCreate.errors.length > 0) {
+    throw new Error(`Failed to create agent: ${result.aiCatalogAgentCreate.errors.join(", ")}`);
+  }
+  return result.aiCatalogAgentCreate.item;
+}
+async function updateAgent(instanceUrl, token, itemId, params) {
+  const gid = normalizeItemGid(itemId);
+  const input = { id: gid };
+  if (params.name !== void 0) input.name = params.name;
+  if (params.description !== void 0) input.description = params.description;
+  if (params.public !== void 0) input.public = params.public;
+  if (params.systemPrompt !== void 0) input.systemPrompt = params.systemPrompt;
+  if (params.userPrompt !== void 0) input.userPrompt = params.userPrompt;
+  if (params.tools !== void 0) input.tools = params.tools;
+  if (params.mcpTools !== void 0) input.mcpTools = params.mcpTools;
+  if (params.mcpServers !== void 0) input.mcpServers = params.mcpServers;
+  if (params.release !== void 0) input.release = params.release;
+  if (params.versionBump) input.versionBump = params.versionBump;
+  const result = await gql(instanceUrl, token, UPDATE_AGENT_MUTATION, { input });
+  if (result.aiCatalogAgentUpdate.errors.length > 0) {
+    throw new Error(`Failed to update agent: ${result.aiCatalogAgentUpdate.errors.join(", ")}`);
+  }
+  return result.aiCatalogAgentUpdate.item;
+}
+async function listBuiltInTools(instanceUrl, token) {
+  const result = await gql(instanceUrl, token, LIST_BUILTIN_TOOLS_QUERY, {});
+  return result.aiCatalogBuiltInTools?.nodes ?? [];
+}
 
 // src/agents.ts
 function resolveModelId(entry) {
@@ -4429,13 +4592,73 @@ function readAuth() {
     return null;
   }
 }
+function buildFlowSubagentPrompt(flow, projectPath, projectUrl) {
+  return [
+    `You execute the "${flow.name}" GitLab flow. Project: ${projectPath} (${projectUrl}).`,
+    ``,
+    `STEP 1: Call gitlab_get_flow_definition with consumer_id=${flow.consumerId}, foundational=${!!flow.foundational}.`,
+    `Parse the YAML config:`,
+    `- In "components", find { from: "context:goal", as: "<name>" }. The "as" value is what the goal parameter must contain:`,
+    `  "merge_request_iid" -> just the number (e.g. 14)`,
+    `  "pipeline_url"/"url"/"issue_url" -> full URL (e.g. ${projectUrl}/-/merge_requests/5)`,
+    `  "vulnerability_id" -> just the ID number`,
+    `  "goal" -> free-form text`,
+    `- In "flow.inputs", find additional_context categories (skip "agent_platform_standard_context").`,
+    ``,
+    `STEP 2: Resolve the goal to the EXACT value the flow expects (from step 1).`,
+    `The goal parameter has a 10000 char limit and is used directly as the flow parameter \u2014 pass ONLY the raw value, never a sentence.`,
+    `Use GitLab API tools if needed to look up IDs or construct URLs from the user's message.`,
+    ``,
+    `STEP 3: Gather additional_context values (if any from step 1) using available tools.`,
+    ``,
+    `STEP 4: Call gitlab_execute_project_flow with:`,
+    `  project_id: "${projectPath}"`,
+    `  consumer_id: ${flow.consumerId}`,
+    `  goal: <resolved value from step 2>`,
+    `  additional_context (if needed): [{"Category":"<cat>","Content":"{\\"field\\":\\"val\\"}"}]`,
+    ``,
+    `STEP 5: Call gitlab_get_workflow_status with the workflow_id. Report status and URL: ${projectUrl}/-/automate/agent-sessions/<id>`
+  ].join("\n");
+}
 var memo = /* @__PURE__ */ new Map();
+var FLOW_DISPATCH_GUIDELINES = [
+  `## GitLab Flow Dispatch Guidelines`,
+  ``,
+  `CRITICAL: You must NEVER call gitlab_execute_project_flow or gitlab_get_flow_definition directly.`,
+  `Flows are ALWAYS executed via the Task tool with subagent_type "general".`,
+  `When the user's message contains flow dispatch instructions (starting with "IMPORTANT: You MUST"),`,
+  `follow those instructions exactly \u2014 call the Task tool with the provided parameters.`,
+  ``,
+  `### Multiple Flows or Resources`,
+  `When multiple flows need to run (multiple @mentions, or batch across resources), dispatch them`,
+  `via a SINGLE "general" subagent. The general subagent can execute multiple tool calls in parallel,`,
+  `so all flows fire simultaneously. Do NOT dispatch multiple Task calls \u2014 use ONE Task with a prompt`,
+  `that lists all the flows to execute, so the subagent runs them concurrently.`,
+  ``,
+  `### Batch Operations (Multiple Resources)`,
+  `If the user asks to run flows on multiple resources (e.g., "for each MR"), first list the`,
+  `resources yourself using GitLab API tools, then dispatch ONE general subagent whose prompt`,
+  `includes all flow executions (N flows x M resources) to run in parallel.`
+].join("\n");
+var AGENT_CREATION_GUIDELINES = `## Creating Custom GitLab Agents
+
+Before calling gitlab_create_agent, you MUST:
+1. Call gitlab_list_builtin_tools and gitlab_list_project_mcp_servers.
+2. Ask the user 4 questions using the question tool (one call, all 4 questions):
+   - Agent name (suggest one, allow custom)
+   - Visibility: Public or Private
+   - Tools: show tools grouped by category as multi-select (Search, Issues, MRs, Epics, Files, Git, CI/CD, Security, Audit, Planning, Wiki, API)
+   - MCP servers: multi-select from available servers
+3. Show the generated system prompt and ask for confirmation.
+4. Only then call gitlab_create_agent. Use full tool GIDs like "gid://gitlab/Ai::Catalog::BuiltInTool/1".
+5. Ask if the user wants to enable it on the current project.`;
 var plugin = async (input) => {
   let authCache = null;
   let projectPath;
   let namespaceId;
   const flowAgents = /* @__PURE__ */ new Map();
   const gitlabAgentNames = /* @__PURE__ */ new Set();
+  let cachedAgents = [];
   let cfgRef = null;
   let baseModelIdRef;
   async function load2() {
@@ -4479,10 +4702,14 @@ var plugin = async (input) => {
       currentNames.add(dName);
       if (isFlow && agent.consumerId && projectPath) {
         flowAgents.set(dName, agent);
+        const rBaseUrl = authCache?.instanceUrl?.replace(/\/$/, "") ?? "https://gitlab.com";
+        const rProjectUrl = `${rBaseUrl}/${projectPath}`;
         cfgRef.agent[dName] = {
           name: dName,
           description: `[GitLab Flow] ${agent.description}`,
-          mode: "subagent"
+          mode: "subagent",
+          prompt: buildFlowSubagentPrompt(agent, projectPath, rProjectUrl),
+          permission: { "*": "allow" }
         };
       } else {
         gitlabAgentNames.add(dName);
@@ -4511,20 +4738,25 @@ var plugin = async (input) => {
     async config(cfg) {
       const result = await load2();
       if (!result?.agents.length) return;
+      cachedAgents = result.agents;
       const baseModelId = resolveModelId(result.entry);
       cfg.agent ??= {};
       cfgRef = cfg;
       baseModelIdRef = baseModelId;
+      const cfgBaseUrl = authCache?.instanceUrl?.replace(/\/$/, "") ?? "https://gitlab.com";
       for (const agent of result.agents) {
         const isFlow = agent.itemType === "FLOW";
         const icon = agent.foundational ? " \u{1F98A}" : "";
         if (isFlow && agent.consumerId && projectPath) {
           const displayName = `${agent.name}${icon}`;
           flowAgents.set(displayName, agent);
+          const pUrl = `${cfgBaseUrl}/${projectPath}`;
           cfg.agent[displayName] = {
             name: displayName,
             description: `[GitLab Flow] ${agent.description}`,
-            mode: "subagent"
+            mode: "subagent",
+            prompt: buildFlowSubagentPrompt(agent, projectPath, pUrl),
+            permission: { "*": "allow" }
           };
         } else {
           const displayName = `${agent.name}${icon}`;
@@ -4547,83 +4779,105 @@ var plugin = async (input) => {
     },
     "chat.message": async (_input, output) => {
       const indicesToRemove = [];
-      const replacements = [];
+      const flowMentions = [];
       for (let i = 0; i < output.parts.length; i++) {
         const part = output.parts[i];
         if (part.type !== "agent") continue;
         const flow = flowAgents.get(part.name);
         if (!flow || !flow.consumerId || !projectPath) continue;
-        const rawText = output.parts.filter((p) => p.type === "text" && !p.synthetic).map((p) => p.text).join(" ").trim() || "Execute the flow";
-        const baseUrl = authCache?.instanceUrl?.replace(/\/$/, "") ?? "https://gitlab.com";
-        const projectUrl = `${baseUrl}/${projectPath}`;
-        const subagentPrompt = [
-          `Execute the "${flow.name}" GitLab flow on project ${projectPath} (${projectUrl}).`,
-          `User goal: "${rawText}"`,
-          ``,
-          `You have access to ALL available tools: GitLab API tools (gitlab_list_merge_requests, gitlab_get_merge_request, gitlab_list_pipelines, gitlab_get_pipeline, gitlab_list_issues, gitlab_get_issue, gitlab_search, etc.), MCP servers, file tools, and any other tools in your environment. Use whatever tools you need to gather the required flow inputs.`,
-          ``,
-          `STEP 1 - FETCH AND DISPLAY FLOW DEFINITION:`,
-          `Call gitlab_get_flow_definition with consumer_id: ${flow.consumerId} and foundational: ${!!flow.foundational}.`,
-          `The response has a "config" field containing YAML. Parse it and find the "flow:" \u2192 "inputs:" section.`,
-          `Each input has a "category" and "input_schema" with field names and types.`,
-          `Print ALL inputs you found. Skip "agent_platform_standard_context" (auto-injected by server).`,
-          `If the config has no "inputs" or "inputs: []", say "No required inputs" and skip to step 3.`,
-          ``,
-          `STEP 2 - GATHER INPUT VALUES:`,
-          `For each required input from step 1, be creative and resourceful in finding the real values:`,
-          `- Use ANY available tools to find the data: GitLab tools, MCP servers, search, file reads, etc.`,
-          `- Look at the user's goal for hints (MR numbers, pipeline IDs, branch names, URLs)`,
-          `- For URL fields: construct full GitLab URLs using base ${projectUrl}`,
-          `- For branch fields: look up from MRs, pipelines, or project default branch`,
-          `- For IDs: extract from the user's message or look up via GitLab API`,
-          `- If an input cannot be determined, ask yourself what makes sense given the context`,
-          `Print each resolved input value before proceeding.`,
-          ``,
-          `STEP 3 - EXECUTE THE FLOW:`,
-          `Call gitlab_execute_project_flow with:`,
-          `- project_id: "${projectPath}"`,
-          `- consumer_id: ${flow.consumerId}`,
-          `- goal: the user's goal with any relevant URLs/context appended`,
-          `- additional_context: JSON array of inputs from step 2, each entry: {"Category":"<category>","Content":"{\\"field\\":\\"value\\"}"}`,
-          `  Example: [{"Category":"merge_request","Content":"{\\"url\\":\\"${projectUrl}/-/merge_requests/12\\"}"}]`,
-          ``,
-          `STEP 4 - CONFIRM FLOW STARTED:`,
-          `Call gitlab_get_workflow_status with the returned workflow_id.`,
-          `The tool blocks automatically while status is CREATED (up to 2 minutes).`,
-          `Once it returns, report:`,
-          `- The workflow status (RUNNING, FINISHED, FAILED, etc.)`,
-          `- The workflow URL: ${projectUrl}/-/automate/agent-sessions/<workflow_id>`,
-          `- A brief summary of what was executed`,
-          `Then stop. Do NOT keep polling. The user can follow the flow execution in the GitLab UI.`
-        ].join("\n");
+        flowMentions.push({ idx: i, flow, displayName: part.name });
+        if (i + 1 < output.parts.length) {
+          const next = output.parts[i + 1];
+          if (next.type === "text" && next.synthetic && next.text?.includes("call the task tool with subagent")) {
+            indicesToRemove.push(i + 1);
+          }
+        }
+      }
+      if (flowMentions.length === 0) {
+        return;
+      }
+      if (flowMentions.length === 1) {
+        const { idx, flow } = flowMentions[0];
+        const baseUrl2 = authCache?.instanceUrl?.replace(/\/$/, "") ?? "https://gitlab.com";
+        const projectUrl2 = `${baseUrl2}/${projectPath}`;
+        const rawText2 = output.parts.filter((p) => p.type === "text" && !p.synthetic).map((p) => p.text).join(" ").trim() || "Execute the flow";
+        const subagentPrompt = buildFlowSubagentPrompt(flow, projectPath, projectUrl2) + `
+
+User goal: "${rawText2}"`;
         const resultText = [
           `IMPORTANT: You MUST call the Task tool RIGHT NOW to dispatch a subagent. Do NOT execute these steps yourself.`,
           ``,
           `Call the Task tool with:`,
+          `  subagent_type: "general"`,
           `  description: "Execute ${flow.name} flow"`,
           `  prompt: ${JSON.stringify(subagentPrompt)}`,
           ``,
           `Do not do anything else. Just call the Task tool with the above parameters.`
         ].join("\n");
-        replacements.push({ idx: i, text: resultText });
-        if (i + 1 < output.parts.length) {
-          const next = output.parts[i + 1];
-          if (next.type === "text" && next.synthetic && next.text?.includes("call the task tool with subagent")) {
-            indicesToRemove.push(i + 1);
-          }
-        }
-      }
-      for (const { idx, text } of replacements) {
-        const original = output.parts[idx];
-        output.parts[idx] = {
-          ...original,
-          type: "text",
-          text
-        };
+        const original2 = output.parts[idx];
+        output.parts[idx] = { ...original2, type: "text", text: resultText };
         delete output.parts[idx].name;
         delete output.parts[idx].source;
+        for (const rmIdx of indicesToRemove.reverse()) {
+          output.parts.splice(rmIdx, 1);
+        }
+        return;
       }
-      for (const idx of indicesToRemove.reverse()) {
+      const baseUrl = authCache?.instanceUrl?.replace(/\/$/, "") ?? "https://gitlab.com";
+      const projectUrl = `${baseUrl}/${projectPath}`;
+      const flowNames = new Set(flowMentions.map((m) => m.displayName));
+      let rawText = output.parts.filter((p) => p.type === "text" && !p.synthetic).map((p) => p.text).join(" ").trim() || "Execute the flows";
+      for (const name of flowNames) {
+        rawText = rawText.replace(new RegExp(`@${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "g"), "").trim();
+      }
+      rawText = rawText.replace(/\s{2,}/g, " ").trim() || "Execute the flows";
+      const flowList = flowMentions.map(
+        ({ flow, displayName }, i) => `${i + 1}. "${displayName}" \u2014 consumer_id=${flow.consumerId}, foundational=${!!flow.foundational}`
+      );
+      const batchPrompt = [
+        `Execute ${flowMentions.length} GitLab flows on project ${projectPath} (${projectUrl}).`,
+        `User goal: "${rawText}"`,
+        ``,
+        `Flows to execute:`,
+        ...flowList,
+        ``,
+        `EXECUTION PLAN:`,
+        `1. Call gitlab_get_flow_definition for ALL flows listed above in a SINGLE response (${flowMentions.length} tool calls at once).`,
+        `   Parse each YAML to find what "context:goal" maps to (the "as" field in components).`,
+        ``,
+        `2. If the user's goal involves multiple resources (e.g., "for each MR"), list them using GitLab API tools.`,
+        ``,
+        `3. Call gitlab_execute_project_flow for EVERY flow+resource combination in a SINGLE response.`,
+        `   For each call, set the goal to the EXACT value the flow expects (e.g., just "14" for merge_request_iid).`,
+        `   project_id: "${projectPath}"`,
+        `   You MUST emit ALL execute calls in ONE response \u2014 do NOT wait for one to finish before calling the next.`,
+        ``,
+        `4. Collect all workflow_ids from step 3. Call gitlab_get_workflow_status for ALL of them in a SINGLE response.`,
+        ``,
+        `5. Present a summary table: flow name, resource, status, URL (${projectUrl}/-/automate/agent-sessions/<id>).`,
+        ``,
+        `CRITICAL: In steps 1, 3, and 4 you MUST make multiple tool calls in the SAME response for parallel execution.`
+      ].join("\n");
+      const combinedText = [
+        `IMPORTANT: You MUST call the Task tool RIGHT NOW with subagent_type "general" to dispatch all flows in parallel.`,
+        `Do NOT call flow tools yourself. Do NOT dispatch multiple Task calls \u2014 use ONE.`,
+        ``,
+        `Call the Task tool with:`,
+        `  subagent_type: "general"`,
+        `  description: "Execute ${flowMentions.length} flows in parallel"`,
+        `  prompt: ${JSON.stringify(batchPrompt)}`,
+        ``,
+        `Do not do anything else. Just call the Task tool with the above parameters.`
+      ].join("\n");
+      const firstIdx = flowMentions[0].idx;
+      const original = output.parts[firstIdx];
+      output.parts[firstIdx] = { ...original, type: "text", text: combinedText };
+      delete output.parts[firstIdx].name;
+      delete output.parts[firstIdx].source;
+      for (let i = flowMentions.length - 1; i >= 1; i--) {
+        indicesToRemove.push(flowMentions[i].idx);
+      }
+      for (const idx of [...new Set(indicesToRemove)].sort((a, b) => b - a)) {
         output.parts.splice(idx, 1);
       }
     },
@@ -4639,6 +4893,14 @@ var plugin = async (input) => {
         );
       }
     },
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (flowAgents.size) {
+        output.system.push(FLOW_DISPATCH_GUIDELINES);
+      }
+      if (authCache) {
+        output.system.push(AGENT_CREATION_GUIDELINES);
+      }
+    },
     tool: {
       gitlab_execute_project_flow: tool({
         description: "Execute a GitLab DAP flow on a project.\nTriggers a flow via the Duo Workflow Service REST API.\nThe flow runs asynchronously and is visible in the GitLab UI.\nReturns the workflow record with ID and status.\nThe additional_context parameter accepts flow-specific inputs as a JSON array of {Category, Content} objects.",
@@ -4737,6 +4999,134 @@ var plugin = async (input) => {
           }
         }
       }),
+      gitlab_list_project_mcp_servers: tool({
+        description: "List MCP servers available through agents enabled for a project.\nReturns deduplicated servers with name, URL, auth type, connection status, and which agents use them.",
+        args: {
+          project_id: z.string().describe('Project path (e.g., "gitlab-org/gitlab")')
+        },
+        execute: async (_args) => {
+          const serverMap = /* @__PURE__ */ new Map();
+          for (const agent of cachedAgents) {
+            if (!agent.mcpServers?.length) continue;
+            for (const server of agent.mcpServers) {
+              const existing = serverMap.get(server.id);
+              if (existing) {
+                if (!existing.usedBy.includes(agent.name)) existing.usedBy.push(agent.name);
+              } else {
+                serverMap.set(server.id, { ...server, usedBy: [agent.name] });
+              }
+            }
+          }
+          const servers = [...serverMap.values()];
+          if (!servers.length) {
+            return "No MCP servers found for agents enabled in this project.";
+          }
+          return JSON.stringify(servers, null, 2);
+        }
+      }),
+      gitlab_create_agent: tool({
+        description: "Create a new custom agent in the GitLab AI Catalog.\nFirst call: set confirmed=false (or omit). The tool returns without creating anything and instructs you to ask the user for agent properties using the question tool.\nSecond call: after the user confirms, set confirmed=true to actually create the agent.\nAfter creation, use gitlab_enable_project_agent to enable it on a project.",
+        args: {
+          project_id: z.string().describe('Project path (e.g., "gitlab-org/gitlab")'),
+          name: z.string().describe("Display name for the agent"),
+          description: z.string().describe("Description of what the agent does"),
+          public: z.boolean().describe("Whether the agent is publicly visible in the AI Catalog"),
+          system_prompt: z.string().describe("System prompt that defines the agent's behavior"),
+          user_prompt: z.string().optional().describe("User prompt template (optional)"),
+          tools: z.array(z.string()).optional().describe(
+            'Array of built-in tool Global IDs from gitlab_list_builtin_tools. Must be full GIDs like "gid://gitlab/Ai::Catalog::BuiltInTool/1", NOT tool names.'
+          ),
+          mcp_tools: z.array(z.string()).optional().describe("Array of MCP tool names to enable"),
+          mcp_servers: z.array(z.string()).optional().describe(
+            'Array of MCP server Global IDs from gitlab_list_project_mcp_servers. Must be full GIDs like "gid://gitlab/Ai::Catalog::McpServer/1", NOT server names.'
+          ),
+          release: z.boolean().optional().describe("Whether to release the version immediately (default: false)"),
+          confirmed: z.boolean().optional().describe(
+            "Set to true only after the user has reviewed and confirmed all parameters. Omit or set false on first call."
+          )
+        },
+        execute: async (args) => {
+          if (!args.confirmed) {
+            return [
+              "STOP: Do not create the agent yet. You must ask the user to confirm the configuration first.",
+              "",
+              "Follow these steps NOW:",
+              "1. Call gitlab_list_builtin_tools and gitlab_list_project_mcp_servers to discover options.",
+              "2. Use the question tool to ask the user ALL 4 of these (in one call):",
+              "   - Agent name (suggest one, allow custom input)",
+              "   - Visibility: Public or Private",
+              "   - Tools: group by category (Search, Issues, MRs, Epics, Files, Git, CI/CD, Security, Audit, Planning, Wiki, API) as multi-select",
+              "   - MCP servers: multi-select from available servers",
+              "3. Generate a system prompt and show it to the user for approval.",
+              "4. Call gitlab_create_agent again with confirmed=true after the user approves."
+            ].join("\n");
+          }
+          const auth = authCache ?? readAuth();
+          if (!auth) throw new Error("Not authenticated");
+          const result = await createAgent(auth.instanceUrl, auth.token, args.project_id, {
+            name: args.name,
+            description: args.description,
+            public: args.public,
+            systemPrompt: args.system_prompt,
+            userPrompt: args.user_prompt,
+            tools: args.tools,
+            mcpTools: args.mcp_tools,
+            mcpServers: args.mcp_servers,
+            release: args.release
+          });
+          await refreshAgents();
+          return JSON.stringify(result, null, 2);
+        }
+      }),
+      gitlab_update_agent: tool({
+        description: "Update an existing custom agent in the GitLab AI Catalog.\nOnly provided fields are updated; omitted fields remain unchanged.",
+        args: {
+          id: z.string().describe("Agent ID (numeric or full GID)"),
+          name: z.string().optional().describe("New display name"),
+          description: z.string().optional().describe("New description"),
+          public: z.boolean().optional().describe("Whether publicly visible"),
+          system_prompt: z.string().optional().describe("New system prompt"),
+          user_prompt: z.string().optional().describe("New user prompt template"),
+          tools: z.array(z.string()).optional().describe(
+            'New set of built-in tool Global IDs (full GIDs like "gid://gitlab/Ai::Catalog::BuiltInTool/1")'
+          ),
+          mcp_tools: z.array(z.string()).optional().describe("New set of MCP tool names"),
+          mcp_servers: z.array(z.string()).optional().describe(
+            'New set of MCP server Global IDs (full GIDs like "gid://gitlab/Ai::Catalog::McpServer/1")'
+          ),
+          release: z.boolean().optional().describe("Whether to release the latest version"),
+          version_bump: z.enum(["MAJOR", "MINOR", "PATCH"]).optional().describe("Version bump type")
+        },
+        execute: async (args) => {
+          const auth = authCache ?? readAuth();
+          if (!auth) throw new Error("Not authenticated");
+          const result = await updateAgent(auth.instanceUrl, auth.token, args.id, {
+            name: args.name,
+            description: args.description,
+            public: args.public,
+            systemPrompt: args.system_prompt,
+            userPrompt: args.user_prompt,
+            tools: args.tools,
+            mcpTools: args.mcp_tools,
+            mcpServers: args.mcp_servers,
+            release: args.release,
+            versionBump: args.version_bump
+          });
+          await refreshAgents();
+          return JSON.stringify(result, null, 2);
+        }
+      }),
+      gitlab_list_builtin_tools: tool({
+        description: "List available built-in GitLab tools that can be assigned to custom agents.\nReturns tool IDs, names, and descriptions. Use the IDs when creating or updating agents.",
+        args: {},
+        execute: async () => {
+          const auth = authCache ?? readAuth();
+          if (!auth) throw new Error("Not authenticated");
+          const tools = await listBuiltInTools(auth.instanceUrl, auth.token);
+          if (!tools.length) return "No built-in tools available.";
+          return JSON.stringify(tools, null, 2);
+        }
+      }),
       ...makeAgentFlowTools(
         z,
         () => authCache,