@gitlab/gitlab-ai-provider 3.1.1 → 3.1.3

package/dist/index.js

@@ -29,13 +29,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ANTHROPIC_TOOLS: () => ANTHROPIC_TOOLS,
-  AnthropicToolExecutor: () => AnthropicToolExecutor,
   BUNDLED_CLIENT_ID: () => BUNDLED_CLIENT_ID,
-  GITLAB_API_TOOLS: () => GITLAB_API_TOOLS,
+  DEFAULT_AI_GATEWAY_URL: () => DEFAULT_AI_GATEWAY_URL,
   GITLAB_COM_URL: () => GITLAB_COM_URL,
   GitLabAgenticLanguageModel: () => GitLabAgenticLanguageModel,
-  GitLabApiToolExecutor: () => GitLabApiToolExecutor,
+  GitLabDirectAccessClient: () => GitLabDirectAccessClient,
   GitLabError: () => GitLabError,
   GitLabOAuthManager: () => GitLabOAuthManager,
   GitLabProjectCache: () => GitLabProjectCache,
@@ -45,8 +43,7 @@ __export(index_exports, {
   TOKEN_EXPIRY_SKEW_MS: () => TOKEN_EXPIRY_SKEW_MS,
   createGitLab: () => createGitLab,
   getAnthropicModelForModelId: () => getAnthropicModelForModelId,
-  gitlab: () => gitlab,
-  isGitLabApiTool: () => isGitLabApiTool
+  gitlab: () => gitlab
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -97,14 +94,17 @@ var directAccessTokenSchema = import_zod.z.object({
   headers: import_zod.z.record(import_zod.z.string()),
   token: import_zod.z.string()
 });
+var DEFAULT_AI_GATEWAY_URL = "https://cloud.gitlab.com";
 var GitLabDirectAccessClient = class {
   config;
   fetchFn;
+  aiGatewayUrl;
   cachedToken = null;
   tokenExpiresAt = 0;
   constructor(config) {
     this.config = config;
     this.fetchFn = config.fetch ?? fetch;
+    this.aiGatewayUrl = config.aiGatewayUrl || process.env["GITLAB_AI_GATEWAY_URL"] || DEFAULT_AI_GATEWAY_URL;
   }
   /**
    * Get a direct access token for the Anthropic proxy.
@@ -141,12 +141,23 @@ var GitLabDirectAccessClient = class {
             return await this.getDirectAccessToken(true);
           } catch (refreshError) {
             throw new GitLabError({
-              message: `Failed to get direct access token: ${response.status} ${response.statusText} - ${errorText}`
+              message: `Failed to get direct access token: ${response.status} ${response.statusText} - ${errorText}`,
+              statusCode: response.status,
+              responseBody: errorText
             });
           }
         }
+        if (response.status === 403) {
+          throw new GitLabError({
+            message: `Access denied to GitLab AI features (${this.config.instanceUrl}). This may indicate that: (1) GitLab Duo is not enabled on this instance, (2) Your account does not have access to AI features, or (3) The third-party agents feature is not available. Original error: ${response.status} ${response.statusText} - ${errorText}`,
+            statusCode: response.status,
+            responseBody: errorText
+          });
+        }
         throw new GitLabError({
-          message: `Failed to get direct access token: ${response.status} ${response.statusText} - ${errorText}`
+          message: `Failed to get direct access token: ${response.status} ${response.statusText} - ${errorText}`,
+          statusCode: response.status,
+          responseBody: errorText
         });
       }
       const data = await response.json();
@@ -168,7 +179,8 @@ var GitLabDirectAccessClient = class {
    * Get the Anthropic proxy base URL
    */
   getAnthropicProxyUrl() {
-    return "https://cloud.gitlab.com/ai/v1/proxy/anthropic/";
+    const baseUrl = this.aiGatewayUrl.replace(/\/$/, "");
+    return `${baseUrl}/ai/v1/proxy/anthropic/`;
   }
   /**
    * Invalidate the cached token
@@ -195,7 +207,8 @@ var GitLabAgenticLanguageModel = class {
       getHeaders: config.getHeaders,
       refreshApiKey: config.refreshApiKey,
       fetch: config.fetch,
-      featureFlags: config.featureFlags
+      featureFlags: config.featureFlags,
+      aiGatewayUrl: config.aiGatewayUrl
     });
   }
   get provider() {
@@ -207,10 +220,12 @@ var GitLabAgenticLanguageModel = class {
    */
   async getAnthropicClient(forceRefresh = false) {
     const tokenData = await this.directAccessClient.getDirectAccessToken(forceRefresh);
+    const { "x-api-key": _removed, ...filteredHeaders } = tokenData.headers;
     this.anthropicClient = new import_sdk.default({
+      apiKey: null,
       authToken: tokenData.token,
       baseURL: this.directAccessClient.getAnthropicProxyUrl(),
-      defaultHeaders: tokenData.headers
+      defaultHeaders: filteredHeaders
     });
     return this.anthropicClient;
   }
@@ -444,114 +459,155 @@ var GitLabAgenticLanguageModel = class {
     const self = this;
     const stream = new ReadableStream({
       start: async (controller) => {
+        const contentBlocks = {};
+        const usage = {
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0
+        };
+        let finishReason = "unknown";
         try {
-          const anthropicStream = client.messages.stream(requestBody);
-          let currentTextBlockId = null;
-          let currentToolBlockId = null;
-          let currentToolName = null;
-          const usage = {
-            inputTokens: 0,
-            outputTokens: 0,
-            totalTokens: 0
-          };
-          let finishReason = "unknown";
+          const anthropicStream = client.messages.stream(requestBody, {
+            signal: options.abortSignal
+          });
           controller.enqueue({
             type: "stream-start",
             warnings: []
           });
-          for await (const event of anthropicStream) {
-            switch (event.type) {
-              case "message_start":
-                if (event.message.usage) {
-                  usage.inputTokens = event.message.usage.input_tokens;
-                }
-                controller.enqueue({
-                  type: "response-metadata",
-                  id: event.message.id,
-                  modelId: event.message.model
-                });
-                break;
-              case "content_block_start":
-                if (event.content_block.type === "text") {
-                  currentTextBlockId = `text-${event.index}`;
-                  controller.enqueue({
-                    type: "text-start",
-                    id: currentTextBlockId
-                  });
-                } else if (event.content_block.type === "tool_use") {
-                  currentToolBlockId = event.content_block.id;
-                  currentToolName = event.content_block.name;
-                  controller.enqueue({
-                    type: "tool-input-start",
-                    id: currentToolBlockId,
-                    toolName: currentToolName
-                  });
-                }
-                break;
-              case "content_block_delta":
-                if (event.delta.type === "text_delta" && currentTextBlockId) {
-                  controller.enqueue({
-                    type: "text-delta",
-                    id: currentTextBlockId,
-                    delta: event.delta.text
-                  });
-                } else if (event.delta.type === "input_json_delta" && currentToolBlockId) {
-                  controller.enqueue({
-                    type: "tool-input-delta",
-                    id: currentToolBlockId,
-                    delta: event.delta.partial_json
-                  });
-                }
-                break;
-              case "content_block_stop":
-                if (currentTextBlockId) {
-                  controller.enqueue({
-                    type: "text-end",
-                    id: currentTextBlockId
-                  });
-                  currentTextBlockId = null;
-                }
-                if (currentToolBlockId) {
-                  controller.enqueue({
-                    type: "tool-input-end",
-                    id: currentToolBlockId
-                  });
-                  currentToolBlockId = null;
-                  currentToolName = null;
-                }
-                break;
-              case "message_delta":
-                if (event.usage) {
-                  usage.outputTokens = event.usage.output_tokens;
-                  usage.totalTokens = (usage.inputTokens || 0) + event.usage.output_tokens;
-                }
-                if (event.delta.stop_reason) {
-                  finishReason = self.convertFinishReason(event.delta.stop_reason);
-                }
-                break;
-              case "message_stop": {
-                const finalMessage = await anthropicStream.finalMessage();
-                for (const block of finalMessage.content) {
-                  if (block.type === "tool_use") {
+          await new Promise((resolve2, reject) => {
+            anthropicStream.on("streamEvent", (event) => {
+              try {
+                switch (event.type) {
+                  case "message_start":
+                    if (event.message.usage) {
+                      usage.inputTokens = event.message.usage.input_tokens;
+                    }
+                    controller.enqueue({
+                      type: "response-metadata",
+                      id: event.message.id,
+                      modelId: event.message.model
+                    });
+                    break;
+                  case "content_block_start":
+                    if (event.content_block.type === "text") {
+                      const textId = `text-${event.index}`;
+                      contentBlocks[event.index] = { type: "text", id: textId };
+                      controller.enqueue({
+                        type: "text-start",
+                        id: textId
+                      });
+                    } else if (event.content_block.type === "tool_use") {
+                      contentBlocks[event.index] = {
+                        type: "tool-call",
+                        toolCallId: event.content_block.id,
+                        toolName: event.content_block.name,
+                        input: ""
+                      };
+                      controller.enqueue({
+                        type: "tool-input-start",
+                        id: event.content_block.id,
+                        toolName: event.content_block.name
+                      });
+                    }
+                    break;
+                  case "content_block_delta": {
+                    const block = contentBlocks[event.index];
+                    if (event.delta.type === "text_delta" && block?.type === "text") {
+                      controller.enqueue({
+                        type: "text-delta",
+                        id: block.id,
+                        delta: event.delta.text
+                      });
+                    } else if (event.delta.type === "input_json_delta" && block?.type === "tool-call") {
+                      block.input += event.delta.partial_json;
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        id: block.toolCallId,
+                        delta: event.delta.partial_json
+                      });
+                    }
+                    break;
+                  }
+                  case "content_block_stop": {
+                    const block = contentBlocks[event.index];
+                    if (block?.type === "text") {
+                      controller.enqueue({
+                        type: "text-end",
+                        id: block.id
+                      });
+                    } else if (block?.type === "tool-call") {
+                      controller.enqueue({
+                        type: "tool-input-end",
+                        id: block.toolCallId
+                      });
+                      controller.enqueue({
+                        type: "tool-call",
+                        toolCallId: block.toolCallId,
+                        toolName: block.toolName,
+                        input: block.input === "" ? "{}" : block.input
+                      });
+                    }
+                    delete contentBlocks[event.index];
+                    break;
+                  }
+                  case "message_delta":
+                    if (event.usage) {
+                      usage.outputTokens = event.usage.output_tokens;
+                      usage.totalTokens = (usage.inputTokens || 0) + event.usage.output_tokens;
+                    }
+                    if (event.delta.stop_reason) {
+                      finishReason = self.convertFinishReason(event.delta.stop_reason);
+                    }
+                    break;
+                  case "message_stop": {
                     controller.enqueue({
-                      type: "tool-call",
-                      toolCallId: block.id,
-                      toolName: block.name,
-                      input: JSON.stringify(block.input)
+                      type: "finish",
+                      finishReason,
+                      usage
                     });
+                    break;
                   }
                 }
-                controller.enqueue({
-                  type: "finish",
-                  finishReason,
-                  usage
-                });
-                break;
+              } catch {
               }
+            });
+            anthropicStream.on("end", () => {
+              resolve2();
+            });
+            anthropicStream.on("error", (error) => {
+              reject(error);
+            });
+          });
+          for (const [, block] of Object.entries(contentBlocks)) {
+            if (block.type === "tool-call") {
+              controller.enqueue({
+                type: "tool-input-end",
+                id: block.toolCallId
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: block.toolCallId,
+                toolName: block.toolName,
+                input: block.input === "" ? "{}" : block.input
+              });
             }
           }
           controller.close();
         } catch (error) {
+          for (const [, block] of Object.entries(contentBlocks)) {
+            if (block.type === "tool-call") {
+              controller.enqueue({
+                type: "tool-input-end",
+                id: block.toolCallId
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: block.toolCallId,
+                toolName: block.toolName,
+                input: block.input === "" ? "{}" : block.input
+              });
+            }
+          }
           if (!isRetry && self.isTokenError(error)) {
             self.directAccessClient.invalidateToken();
             controller.enqueue({
@@ -909,7 +965,8 @@ function createGitLab(options = {}) {
       fetch: options.fetch,
       anthropicModel: agenticOptions?.anthropicModel ?? getAnthropicModelForModelId(modelId),
       maxTokens: agenticOptions?.maxTokens,
-      featureFlags
+      featureFlags,
+      aiGatewayUrl: options.aiGatewayUrl
     });
   };
   const createDefaultModel = (modelId) => {
@@ -935,1196 +992,9 @@ function createGitLab(options = {}) {
 }
 var gitlab = createGitLab();
 
-// src/gitlab-api-tools.ts
-var GITLAB_API_TOOLS = [
-  // Merge Request Tools
-  {
-    name: "gitlab_get_merge_request",
-    description: `Get details of a specific merge request by project and MR IID.
-Returns: title, description, state, author, assignees, reviewers, labels, diff stats, and discussion notes.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: 'The project ID or URL-encoded path (e.g., "gitlab-org/gitlab" or "123")'
-        },
-        mr_iid: {
-          type: "number",
-          description: "The internal ID of the merge request within the project"
-        },
-        include_changes: {
-          type: "boolean",
-          description: "Whether to include the list of changed files (default: false)"
-        }
-      },
-      required: ["project_id", "mr_iid"]
-    }
-  },
-  {
-    name: "gitlab_list_merge_requests",
-    description: `List merge requests for a project or search globally.
-Can filter by state (opened, closed, merged, all), scope (assigned_to_me, created_by_me), and labels.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or path. If not provided, searches globally."
-        },
-        state: {
-          type: "string",
-          enum: ["opened", "closed", "merged", "all"],
-          description: "Filter by MR state (default: opened)"
-        },
-        scope: {
-          type: "string",
-          enum: ["assigned_to_me", "created_by_me", "all"],
-          description: "Filter by scope"
-        },
-        search: {
-          type: "string",
-          description: "Search MRs by title or description"
-        },
-        labels: {
-          type: "string",
-          description: "Comma-separated list of labels to filter by"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of results (default: 20)"
-        }
-      },
-      required: []
-    }
-  },
-  {
-    name: "gitlab_get_mr_changes",
-    description: `Get the file changes (diff) for a merge request.
-Returns the list of files changed with their diffs.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        mr_iid: {
-          type: "number",
-          description: "The internal ID of the merge request"
-        }
-      },
-      required: ["project_id", "mr_iid"]
-    }
-  },
-  {
-    name: "gitlab_list_mr_discussions",
-    description: `List discussions (comments/threads) on a merge request.
-Returns all discussion threads including resolved status.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        mr_iid: {
-          type: "number",
-          description: "The internal ID of the merge request"
-        }
-      },
-      required: ["project_id", "mr_iid"]
-    }
-  },
-  {
-    name: "gitlab_create_mr_note",
-    description: `Add a comment/note to a merge request.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        mr_iid: {
-          type: "number",
-          description: "The internal ID of the merge request"
-        },
-        body: {
-          type: "string",
-          description: "The content of the note/comment (supports Markdown)"
-        }
-      },
-      required: ["project_id", "mr_iid", "body"]
-    }
-  },
-  // Issue Tools
-  {
-    name: "gitlab_get_issue",
-    description: `Get details of a specific issue by project and issue IID.
-Returns: title, description, state, author, assignees, labels, milestone, weight, and comments.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        issue_iid: {
-          type: "number",
-          description: "The internal ID of the issue within the project"
-        }
-      },
-      required: ["project_id", "issue_iid"]
-    }
-  },
-  {
-    name: "gitlab_list_issues",
-    description: `List issues for a project or search globally.
-Can filter by state, labels, assignee, milestone.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or path. If not provided, searches globally."
-        },
-        state: {
-          type: "string",
-          enum: ["opened", "closed", "all"],
-          description: "Filter by issue state (default: opened)"
-        },
-        scope: {
-          type: "string",
-          enum: ["assigned_to_me", "created_by_me", "all"],
-          description: "Filter by scope"
-        },
-        search: {
-          type: "string",
-          description: "Search issues by title or description"
-        },
-        labels: {
-          type: "string",
-          description: "Comma-separated list of labels to filter by"
-        },
-        milestone: {
-          type: "string",
-          description: "Filter by milestone title"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of results (default: 20)"
-        }
-      },
-      required: []
-    }
-  },
-  {
-    name: "gitlab_create_issue_note",
-    description: `Add a comment/note to an issue.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        issue_iid: {
-          type: "number",
-          description: "The internal ID of the issue"
-        },
-        body: {
-          type: "string",
-          description: "The content of the note/comment (supports Markdown)"
-        }
-      },
-      required: ["project_id", "issue_iid", "body"]
-    }
-  },
-  // Pipeline/CI Tools
-  {
-    name: "gitlab_list_pipelines",
-    description: `List pipelines for a project.
-Can filter by status, ref (branch/tag), username.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        status: {
-          type: "string",
-          enum: ["running", "pending", "success", "failed", "canceled", "skipped", "manual"],
-          description: "Filter by pipeline status"
-        },
-        ref: {
-          type: "string",
-          description: "Filter by branch or tag name"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of results (default: 20)"
-        }
-      },
-      required: ["project_id"]
-    }
-  },
-  {
-    name: "gitlab_get_pipeline",
-    description: `Get details of a specific pipeline including its jobs.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        pipeline_id: {
-          type: "number",
-          description: "The ID of the pipeline"
-        }
-      },
-      required: ["project_id", "pipeline_id"]
-    }
-  },
-  {
-    name: "gitlab_list_pipeline_jobs",
-    description: `List jobs for a pipeline, optionally filter by scope (failed, success, etc).`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        pipeline_id: {
-          type: "number",
-          description: "The ID of the pipeline"
-        },
-        scope: {
-          type: "string",
-          enum: [
-            "created",
-            "pending",
-            "running",
-            "failed",
-            "success",
-            "canceled",
-            "skipped",
-            "manual"
-          ],
-          description: "Filter jobs by scope/status"
-        }
-      },
-      required: ["project_id", "pipeline_id"]
-    }
-  },
-  {
-    name: "gitlab_get_job_log",
-    description: `Get the log/trace output of a specific CI job.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        job_id: {
-          type: "number",
-          description: "The ID of the job"
-        }
-      },
-      required: ["project_id", "job_id"]
-    }
-  },
-  {
-    name: "gitlab_retry_job",
-    description: `Retry a failed or canceled CI job.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        job_id: {
-          type: "number",
-          description: "The ID of the job to retry"
-        }
-      },
-      required: ["project_id", "job_id"]
-    }
-  },
-  // Repository Tools
-  {
-    name: "gitlab_get_file",
-    description: `Get the contents of a file from a repository.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        file_path: {
-          type: "string",
-          description: "Path to the file in the repository"
-        },
-        ref: {
-          type: "string",
-          description: "Branch, tag, or commit SHA (default: default branch)"
-        }
-      },
-      required: ["project_id", "file_path"]
-    }
-  },
-  {
-    name: "gitlab_list_commits",
-    description: `List commits in a repository. Can filter by branch/ref and path.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        ref: {
-          type: "string",
-          description: "Branch or tag name"
-        },
-        path: {
-          type: "string",
-          description: "File or directory path to filter commits"
-        },
-        since: {
-          type: "string",
-          description: "Only commits after this date (ISO 8601 format)"
-        },
-        until: {
-          type: "string",
-          description: "Only commits before this date (ISO 8601 format)"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of results (default: 20)"
-        }
-      },
-      required: ["project_id"]
-    }
-  },
-  {
-    name: "gitlab_get_commit_diff",
-    description: `Get the diff for a specific commit.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        sha: {
-          type: "string",
-          description: "The commit SHA"
-        }
-      },
-      required: ["project_id", "sha"]
-    }
-  },
-  {
-    name: "gitlab_list_branches",
-    description: `List branches in a repository.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        },
-        search: {
-          type: "string",
-          description: "Search branches by name"
-        }
-      },
-      required: ["project_id"]
-    }
-  },
-  // Search Tools
-  {
-    name: "gitlab_search",
-    description: `Search across GitLab for various resources.
-Scopes: projects, issues, merge_requests, milestones, users, blobs (code), commits, notes, wiki_blobs`,
-    input_schema: {
-      type: "object",
-      properties: {
-        scope: {
-          type: "string",
-          enum: [
-            "projects",
-            "issues",
-            "merge_requests",
-            "milestones",
-            "users",
-            "blobs",
-            "commits",
-            "notes",
-            "wiki_blobs"
-          ],
-          description: "The scope of the search"
-        },
-        search: {
-          type: "string",
-          description: "The search query"
-        },
-        project_id: {
-          type: "string",
-          description: "Limit search to a specific project (optional)"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of results (default: 20)"
-        }
-      },
-      required: ["scope", "search"]
-    }
-  },
-  // Project Tools
-  {
-    name: "gitlab_get_project",
-    description: `Get details of a specific project.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: 'The project ID or URL-encoded path (e.g., "gitlab-org/gitlab")'
-        }
-      },
-      required: ["project_id"]
-    }
-  },
-  {
-    name: "gitlab_list_project_members",
-    description: `List members of a project.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        project_id: {
-          type: "string",
-          description: "The project ID or URL-encoded path"
-        }
-      },
-      required: ["project_id"]
-    }
-  }
-];
-var GitLabApiToolExecutor = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  get headers() {
-    return {
-      Authorization: `Bearer ${this.config.token}`,
-      "Content-Type": "application/json"
-    };
-  }
-  async fetchApi(method, path4, body) {
-    const url = `${this.config.instanceUrl}/api/v4${path4}`;
-    const fetchFn = this.config.fetch || fetch;
-    const response = await fetchFn(url, {
-      method,
-      headers: this.headers,
-      body: body ? JSON.stringify(body) : void 0
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`GitLab API error ${response.status}: ${errorText}`);
-    }
-    const text = await response.text();
-    if (!text) {
-      return {};
-    }
-    return JSON.parse(text);
-  }
-  encodeProjectId(projectId) {
-    if (projectId.includes("/")) {
-      return encodeURIComponent(projectId);
-    }
-    return projectId;
-  }
-  /**
-   * Execute a GitLab API tool by name
-   */
-  async execute(toolName, input) {
-    try {
-      switch (toolName) {
-        // Merge Request tools
-        case "gitlab_get_merge_request":
-          return this.getMergeRequest(input);
-        case "gitlab_list_merge_requests":
-          return this.listMergeRequests(input);
-        case "gitlab_get_mr_changes":
-          return this.getMrChanges(input);
-        case "gitlab_list_mr_discussions":
-          return this.listMrDiscussions(input);
-        case "gitlab_create_mr_note":
-          return this.createMrNote(input);
-        // Issue tools
-        case "gitlab_get_issue":
-          return this.getIssue(input);
-        case "gitlab_list_issues":
-          return this.listIssues(input);
-        case "gitlab_create_issue_note":
-          return this.createIssueNote(input);
-        // Pipeline tools
-        case "gitlab_list_pipelines":
-          return this.listPipelines(input);
-        case "gitlab_get_pipeline":
-          return this.getPipeline(input);
-        case "gitlab_list_pipeline_jobs":
-          return this.listPipelineJobs(input);
-        case "gitlab_get_job_log":
-          return this.getJobLog(input);
-        case "gitlab_retry_job":
-          return this.retryJob(input);
-        // Repository tools
-        case "gitlab_get_file":
-          return this.getFile(input);
-        case "gitlab_list_commits":
-          return this.listCommits(input);
-        case "gitlab_get_commit_diff":
-          return this.getCommitDiff(input);
-        case "gitlab_list_branches":
-          return this.listBranches(input);
-        // Search tools
-        case "gitlab_search":
-          return this.search(input);
-        // Project tools
-        case "gitlab_get_project":
-          return this.getProject(input);
-        case "gitlab_list_project_members":
-          return this.listProjectMembers(input);
-        default:
-          return { result: "", error: `Unknown GitLab tool: ${toolName}` };
-      }
-    } catch (error) {
-      return {
-        result: "",
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  // ========== Merge Request Tools ==========
-  async getMergeRequest(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const mrIid = input.mr_iid;
-    const includeChanges = input.include_changes;
-    let path4 = `/projects/${projectId}/merge_requests/${mrIid}`;
-    if (includeChanges) {
-      path4 += "?include_diverged_commits_count=true";
-    }
-    const mr = await this.fetchApi("GET", path4);
-    return { result: JSON.stringify(mr, null, 2) };
-  }
-  async listMergeRequests(input) {
-    const params = new URLSearchParams();
-    params.set("per_page", String(input.limit || 20));
-    if (input.state) params.set("state", input.state);
-    if (input.scope) params.set("scope", input.scope);
-    if (input.search) params.set("search", input.search);
-    if (input.labels) params.set("labels", input.labels);
-    let path4;
-    if (input.project_id) {
-      const projectId = this.encodeProjectId(input.project_id);
-      path4 = `/projects/${projectId}/merge_requests?${params}`;
-    } else {
-      path4 = `/merge_requests?${params}`;
-    }
-    const mrs = await this.fetchApi("GET", path4);
-    return { result: JSON.stringify(mrs, null, 2) };
-  }
-  async getMrChanges(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const mrIid = input.mr_iid;
-    const changes = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/merge_requests/${mrIid}/changes`
-    );
-    return { result: JSON.stringify(changes, null, 2) };
-  }
-  async listMrDiscussions(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const mrIid = input.mr_iid;
-    const discussions = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/merge_requests/${mrIid}/discussions`
-    );
-    return { result: JSON.stringify(discussions, null, 2) };
-  }
-  async createMrNote(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const mrIid = input.mr_iid;
-    const body = input.body;
-    const note = await this.fetchApi(
-      "POST",
-      `/projects/${projectId}/merge_requests/${mrIid}/notes`,
-      { body }
-    );
-    return { result: JSON.stringify(note, null, 2) };
-  }
-  // ========== Issue Tools ==========
-  async getIssue(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const issueIid = input.issue_iid;
-    const issue = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/issues/${issueIid}`
-    );
-    return { result: JSON.stringify(issue, null, 2) };
-  }
-  async listIssues(input) {
-    const params = new URLSearchParams();
-    params.set("per_page", String(input.limit || 20));
-    if (input.state) params.set("state", input.state);
-    if (input.scope) params.set("scope", input.scope);
-    if (input.search) params.set("search", input.search);
-    if (input.labels) params.set("labels", input.labels);
-    if (input.milestone) params.set("milestone", input.milestone);
-    let path4;
-    if (input.project_id) {
-      const projectId = this.encodeProjectId(input.project_id);
-      path4 = `/projects/${projectId}/issues?${params}`;
-    } else {
-      path4 = `/issues?${params}`;
-    }
-    const issues = await this.fetchApi("GET", path4);
-    return { result: JSON.stringify(issues, null, 2) };
-  }
-  async createIssueNote(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const issueIid = input.issue_iid;
-    const body = input.body;
-    const note = await this.fetchApi(
-      "POST",
-      `/projects/${projectId}/issues/${issueIid}/notes`,
-      { body }
-    );
-    return { result: JSON.stringify(note, null, 2) };
-  }
-  // ========== Pipeline Tools ==========
-  async listPipelines(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const params = new URLSearchParams();
-    params.set("per_page", String(input.limit || 20));
-    if (input.status) params.set("status", input.status);
-    if (input.ref) params.set("ref", input.ref);
-    const pipelines = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/pipelines?${params}`
-    );
-    return { result: JSON.stringify(pipelines, null, 2) };
-  }
-  async getPipeline(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const pipelineId = input.pipeline_id;
-    const pipeline = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/pipelines/${pipelineId}`
-    );
-    return { result: JSON.stringify(pipeline, null, 2) };
-  }
-  async listPipelineJobs(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const pipelineId = input.pipeline_id;
-    const params = new URLSearchParams();
-    if (input.scope) params.set("scope[]", input.scope);
-    const jobs = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/pipelines/${pipelineId}/jobs?${params}`
-    );
-    return { result: JSON.stringify(jobs, null, 2) };
-  }
-  async getJobLog(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const jobId = input.job_id;
-    const url = `${this.config.instanceUrl}/api/v4/projects/${projectId}/jobs/${jobId}/trace`;
-    const fetchFn = this.config.fetch || fetch;
-    const response = await fetchFn(url, {
-      method: "GET",
-      headers: this.headers
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`GitLab API error ${response.status}: ${errorText}`);
-    }
-    const log = await response.text();
-    const maxLength = 5e4;
-    if (log.length > maxLength) {
-      return {
-        result: `[Log truncated, showing last ${maxLength} characters]
-
-${log.slice(-maxLength)}`
-      };
-    }
-    return { result: log };
-  }
-  async retryJob(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const jobId = input.job_id;
-    const job = await this.fetchApi(
-      "POST",
-      `/projects/${projectId}/jobs/${jobId}/retry`
-    );
-    return { result: JSON.stringify(job, null, 2) };
-  }
-  // ========== Repository Tools ==========
-  async getFile(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const filePath = encodeURIComponent(input.file_path);
-    const ref = input.ref || "HEAD";
-    const file = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/repository/files/${filePath}?ref=${encodeURIComponent(ref)}`
-    );
-    if (file.encoding === "base64") {
-      const decoded = Buffer.from(file.content, "base64").toString("utf-8");
-      return { result: decoded };
-    }
-    return { result: file.content };
-  }
-  async listCommits(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const params = new URLSearchParams();
-    params.set("per_page", String(input.limit || 20));
-    if (input.ref) params.set("ref_name", input.ref);
-    if (input.path) params.set("path", input.path);
-    if (input.since) params.set("since", input.since);
-    if (input.until) params.set("until", input.until);
-    const commits = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/repository/commits?${params}`
-    );
-    return { result: JSON.stringify(commits, null, 2) };
-  }
-  async getCommitDiff(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const sha = input.sha;
-    const diff = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/repository/commits/${sha}/diff`
-    );
-    return { result: JSON.stringify(diff, null, 2) };
-  }
-  async listBranches(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const params = new URLSearchParams();
-    if (input.search) params.set("search", input.search);
-    const branches = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/repository/branches?${params}`
-    );
-    return { result: JSON.stringify(branches, null, 2) };
-  }
-  // ========== Search Tools ==========
-  async search(input) {
-    const scope = input.scope;
-    const searchQuery = input.search;
-    const params = new URLSearchParams();
-    params.set("scope", scope);
-    params.set("search", searchQuery);
-    params.set("per_page", String(input.limit || 20));
-    let path4;
-    if (input.project_id) {
-      const projectId = this.encodeProjectId(input.project_id);
-      path4 = `/projects/${projectId}/search?${params}`;
-    } else {
-      path4 = `/search?${params}`;
-    }
-    const results = await this.fetchApi("GET", path4);
-    return { result: JSON.stringify(results, null, 2) };
-  }
-  // ========== Project Tools ==========
-  async getProject(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const project = await this.fetchApi("GET", `/projects/${projectId}`);
-    return { result: JSON.stringify(project, null, 2) };
-  }
-  async listProjectMembers(input) {
-    const projectId = this.encodeProjectId(input.project_id);
-    const members = await this.fetchApi(
-      "GET",
-      `/projects/${projectId}/members`
-    );
-    return { result: JSON.stringify(members, null, 2) };
-  }
-};
-function isGitLabApiTool(toolName) {
-  return toolName.startsWith("gitlab_");
-}
-
-// src/gitlab-anthropic-tools.ts
-var fs2 = __toESM(require("fs/promises"));
-var path2 = __toESM(require("path"));
-var import_child_process = require("child_process");
-var ANTHROPIC_TOOLS = [
-  {
-    name: "list_dir",
-    description: `List directory contents. Shows files and subdirectories relative to the working directory.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        directory: {
-          type: "string",
-          description: "Directory path relative to the working directory"
-        }
-      },
-      required: ["directory"]
-    }
-  },
-  {
-    name: "read_file",
-    description: `Read the contents of a file.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        file_path: {
-          type: "string",
-          description: "The file path to read"
-        }
-      },
-      required: ["file_path"]
-    }
-  },
-  {
-    name: "create_file_with_contents",
-    description: `Create and write contents to a file.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        file_path: {
-          type: "string",
-          description: "The file path to write to"
-        },
-        contents: {
-          type: "string",
-          description: "The contents to write"
-        }
-      },
-      required: ["file_path", "contents"]
-    }
-  },
-  {
-    name: "edit_file",
-    description: `Edit an existing file by replacing a string with a new string.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        file_path: {
-          type: "string",
-          description: "The path of the file to edit"
-        },
-        old_str: {
-          type: "string",
-          description: "The string to replace (include context for uniqueness)"
-        },
-        new_str: {
-          type: "string",
-          description: "The new string value"
-        }
-      },
-      required: ["file_path", "old_str", "new_str"]
-    }
-  },
-  {
-    name: "find_files",
-    description: `Find files by name pattern. Uses glob-like matching.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        name_pattern: {
-          type: "string",
-          description: 'The pattern to search for (e.g., "*.py", "test_*.js")'
-        }
-      },
-      required: ["name_pattern"]
-    }
-  },
-  {
-    name: "mkdir",
-    description: `Create a new directory.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        directory_path: {
-          type: "string",
-          description: "The directory path to create"
-        }
-      },
-      required: ["directory_path"]
-    }
-  },
-  {
-    name: "grep",
-    description: `Search for text patterns within files.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        pattern: {
-          type: "string",
-          description: "The text pattern to search for"
-        },
-        search_directory: {
-          type: "string",
-          description: 'The directory to search in (default: ".")'
-        },
-        case_insensitive: {
-          type: "boolean",
-          description: "Whether to ignore case (default: false)"
-        }
-      },
-      required: ["pattern"]
-    }
-  },
-  {
-    name: "run_command",
-    description: `Run a shell command. Note: git commands should use run_git_command instead.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        program: {
-          type: "string",
-          description: 'The program to execute (e.g., "npm", "python")'
-        },
-        args: {
-          type: "string",
-          description: "Arguments as a single string"
-        }
-      },
-      required: ["program"]
-    }
-  },
-  {
-    name: "run_git_command",
-    description: `Run a git command in the repository.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        command: {
-          type: "string",
-          description: 'Git command (e.g., "status", "log", "diff")'
-        },
-        args: {
-          type: "string",
-          description: "Git command arguments"
-        }
-      },
-      required: ["command"]
-    }
-  }
-];
-var AnthropicToolExecutor = class {
-  workingDirectory;
-  constructor(workingDirectory) {
-    this.workingDirectory = workingDirectory;
-  }
-  /**
-   * Execute a tool by name with given input
-   */
-  async execute(toolName, input) {
-    try {
-      switch (toolName) {
-        case "list_dir":
-          return this.listDir(input.directory);
-        case "read_file":
-          return this.readFile(input.file_path);
-        case "create_file_with_contents":
-          return this.writeFile(input.file_path, input.contents);
-        case "edit_file":
-          return this.editFile(
-            input.file_path,
-            input.old_str,
-            input.new_str
-          );
-        case "find_files":
-          return this.findFiles(input.name_pattern);
-        case "mkdir":
-          return this.mkdir(input.directory_path);
-        case "grep":
-          return this.grep(
-            input.pattern,
-            input.search_directory,
-            input.case_insensitive
-          );
-        case "run_command":
-          return this.runCommand(input.program, input.args);
-        case "run_git_command":
-          return this.runGitCommand(input.command, input.args);
-        default:
-          return { result: "", error: `Unknown tool: ${toolName}` };
-      }
-    } catch (error) {
-      return {
-        result: "",
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  resolvePath(filePath) {
-    if (path2.isAbsolute(filePath)) {
-      return filePath;
-    }
-    return path2.resolve(this.workingDirectory, filePath);
-  }
-  async listDir(directory) {
-    const dirPath = this.resolvePath(directory || ".");
-    const entries = await fs2.readdir(dirPath, { withFileTypes: true });
-    const result = entries.map((entry) => {
-      const type = entry.isDirectory() ? "d" : "-";
-      return `${type} ${entry.name}`;
-    }).join("\n");
-    return { result };
-  }
-  async readFile(filePath) {
-    const fullPath = this.resolvePath(filePath);
-    const content = await fs2.readFile(fullPath, "utf-8");
-    return { result: content };
-  }
-  async writeFile(filePath, contents) {
-    const fullPath = this.resolvePath(filePath);
-    await fs2.mkdir(path2.dirname(fullPath), { recursive: true });
-    await fs2.writeFile(fullPath, contents, "utf-8");
-    return { result: `File written successfully: ${filePath}` };
-  }
-  async editFile(filePath, oldStr, newStr) {
-    const fullPath = this.resolvePath(filePath);
-    const content = await fs2.readFile(fullPath, "utf-8");
-    if (!content.includes(oldStr)) {
-      return { result: "", error: `String not found in file: "${oldStr.substring(0, 50)}..."` };
-    }
-    const newContent = content.replace(oldStr, newStr);
-    await fs2.writeFile(fullPath, newContent, "utf-8");
-    return { result: `File edited successfully: ${filePath}` };
-  }
-  async findFiles(namePattern) {
-    const results = [];
-    const regex = new RegExp("^" + namePattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
-    const search = async (dir, relativePath = "") => {
-      try {
-        const entries = await fs2.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            if (!["node_modules", ".git", "dist", "build", "__pycache__"].includes(entry.name)) {
-              await search(path2.join(dir, entry.name), entryRelativePath);
-            }
-          } else if (regex.test(entry.name)) {
-            results.push(entryRelativePath);
-          }
-        }
-      } catch {
-      }
-    };
-    await search(this.workingDirectory);
-    return { result: results.join("\n") || "No files found" };
-  }
-  async mkdir(directoryPath) {
-    const fullPath = this.resolvePath(directoryPath);
-    await fs2.mkdir(fullPath, { recursive: true });
-    return { result: `Directory created: ${directoryPath}` };
-  }
-  async grep(pattern, searchDirectory, caseInsensitive) {
-    const results = [];
-    const flags = caseInsensitive ? "gi" : "g";
-    const regex = new RegExp(pattern, flags);
-    const searchDir = this.resolvePath(searchDirectory || ".");
-    const search = async (dir, relativePath = "") => {
-      try {
-        const entries = await fs2.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          const fullPath = path2.join(dir, entry.name);
-          if (entry.isDirectory()) {
-            if (!["node_modules", ".git", "dist", "build", "__pycache__"].includes(entry.name)) {
-              await search(fullPath, entryRelativePath);
-            }
-          } else {
-            try {
-              const content = await fs2.readFile(fullPath, "utf-8");
-              const lines = content.split("\n");
-              for (let i = 0; i < lines.length; i++) {
-                if (regex.test(lines[i])) {
-                  results.push(`${entryRelativePath}:${i + 1}: ${lines[i].trim()}`);
-                }
-              }
-            } catch {
-            }
-          }
-        }
-      } catch {
-      }
-    };
-    await search(searchDir);
-    return { result: results.slice(0, 100).join("\n") || "No matches found" };
-  }
-  runCommand(program, args) {
-    if (program === "git") {
-      return Promise.resolve({
-        result: "",
-        error: "Use run_git_command for git operations"
-      });
-    }
-    const parsedArgs = args ? args.match(/(?:[^\s"]+|"[^"]*")+/g) || [] : [];
-    const cleanedArgs = parsedArgs.map((arg) => arg.replace(/^"(.*)"$/, "$1"));
-    return this.executeCommand(program, cleanedArgs);
-  }
-  runGitCommand(command, args) {
-    const gitArgs = [command];
-    if (args) {
-      const parsedArgs = args.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
-      gitArgs.push(...parsedArgs.map((arg) => arg.replace(/^"(.*)"$/, "$1")));
-    }
-    return this.executeCommand("git", gitArgs);
-  }
-  executeCommand(program, args) {
-    return new Promise((resolve3) => {
-      const child = (0, import_child_process.spawn)(program, args, {
-        cwd: this.workingDirectory,
-        timeout: 3e4
-      });
-      let stdout = "";
-      let stderr = "";
-      child.stdout?.on("data", (data) => {
-        stdout += data.toString();
-      });
-      child.stderr?.on("data", (data) => {
-        stderr += data.toString();
-      });
-      child.on("error", (error) => {
-        resolve3({
-          result: "",
-          error: `Command failed: ${error.message}`
-        });
-      });
-      child.on("close", (exitCode) => {
-        if (exitCode !== 0 && stderr) {
-          resolve3({
-            result: stdout,
-            error: stderr
-          });
-        } else {
-          resolve3({
-            result: stdout || stderr || `Command completed with exit code ${exitCode}`
-          });
-        }
-      });
-    });
-  }
-};
-
 // src/gitlab-project-detector.ts
-var import_child_process2 = require("child_process");
-var path3 = __toESM(require("path"));
+var import_child_process = require("child_process");
+var path2 = __toESM(require("path"));
 
 // src/gitlab-project-cache.ts
 var GitLabProjectCache = class {
@@ -2230,7 +1100,7 @@ var GitLabProjectDetector = class {
    * @returns The detected project or null if detection fails
    */
   async detectProject(workingDirectory, remoteName = "origin") {
-    const cacheKey = path3.resolve(workingDirectory);
+    const cacheKey = path2.resolve(workingDirectory);
     const cached = this.cache.get(cacheKey);
     if (cached) {
       return cached;
@@ -2315,8 +1185,8 @@ var GitLabProjectDetector = class {
    * @returns The remote URL or null if not found
    */
   async getGitRemoteUrl(workingDirectory, remoteName = "origin") {
-    return new Promise((resolve3) => {
-      const child = (0, import_child_process2.spawn)("git", ["config", "--get", `remote.${remoteName}.url`], {
+    return new Promise((resolve2) => {
+      const child = (0, import_child_process.spawn)("git", ["config", "--get", `remote.${remoteName}.url`], {
         cwd: workingDirectory,
         timeout: this.config.gitTimeout
       });
@@ -2330,13 +1200,13 @@ var GitLabProjectDetector = class {
       });
       child.on("close", (exitCode) => {
         if (exitCode === 0 && stdout.trim()) {
-          resolve3(stdout.trim());
+          resolve2(stdout.trim());
         } else {
-          resolve3(null);
+          resolve2(null);
         }
       });
       child.on("error", () => {
-        resolve3(null);
+        resolve2(null);
       });
     });
   }
@@ -2393,13 +1263,11 @@ var GitLabProjectDetector = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ANTHROPIC_TOOLS,
-  AnthropicToolExecutor,
   BUNDLED_CLIENT_ID,
-  GITLAB_API_TOOLS,
+  DEFAULT_AI_GATEWAY_URL,
   GITLAB_COM_URL,
   GitLabAgenticLanguageModel,
-  GitLabApiToolExecutor,
+  GitLabDirectAccessClient,
   GitLabError,
   GitLabOAuthManager,
   GitLabProjectCache,
@@ -2409,7 +1277,6 @@ var GitLabProjectDetector = class {
   TOKEN_EXPIRY_SKEW_MS,
   createGitLab,
   getAnthropicModelForModelId,
-  gitlab,
-  isGitLabApiTool
+  gitlab
 });
 //# sourceMappingURL=index.js.map