@gitlab/gitlab-ai-provider 3.1.0 → 3.1.2

package/dist/index.js

@@ -29,22 +29,21 @@ 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,
   GitLabProjectDetector: () => GitLabProjectDetector,
+  MODEL_ID_TO_ANTHROPIC_MODEL: () => MODEL_ID_TO_ANTHROPIC_MODEL,
   OAUTH_SCOPES: () => OAUTH_SCOPES,
   TOKEN_EXPIRY_SKEW_MS: () => TOKEN_EXPIRY_SKEW_MS,
   createGitLab: () => createGitLab,
-  gitlab: () => gitlab,
-  isGitLabApiTool: () => isGitLabApiTool
+  getAnthropicModelForModelId: () => getAnthropicModelForModelId,
+  gitlab: () => gitlab
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -95,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.
@@ -139,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();
@@ -166,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
@@ -178,6 +192,8 @@ var GitLabDirectAccessClient = class {
 };
 
 // src/gitlab-agentic-language-model.ts
+var debugLog = (..._args) => {
+};
 var GitLabAgenticLanguageModel = class {
   specificationVersion = "v2";
   modelId;
@@ -193,7 +209,8 @@ var GitLabAgenticLanguageModel = class {
       getHeaders: config.getHeaders,
       refreshApiKey: config.refreshApiKey,
       fetch: config.fetch,
-      featureFlags: config.featureFlags
+      featureFlags: config.featureFlags,
+      aiGatewayUrl: config.aiGatewayUrl
     });
   }
   get provider() {
@@ -205,10 +222,19 @@ var GitLabAgenticLanguageModel = class {
    */
   async getAnthropicClient(forceRefresh = false) {
     const tokenData = await this.directAccessClient.getDirectAccessToken(forceRefresh);
+    debugLog("[gitlab-ai-provider] Token headers from GitLab:", tokenData.headers);
+    debugLog("[gitlab-ai-provider] Proxy URL:", this.directAccessClient.getAnthropicProxyUrl());
+    const { "x-api-key": _removed, ...filteredHeaders } = tokenData.headers;
+    if (_removed) {
+      debugLog(
+        "[gitlab-ai-provider] Filtered out x-api-key from headers (using authToken instead)"
+      );
+    }
     this.anthropicClient = new import_sdk.default({
+      apiKey: null,
       authToken: tokenData.token,
       baseURL: this.directAccessClient.getAnthropicProxyUrl(),
-      defaultHeaders: tokenData.headers
+      defaultHeaders: filteredHeaders
     });
     return this.anthropicClient;
   }
@@ -749,6 +775,16 @@ var GitLabOAuthManager = class {
   }
 };
 
+// src/model-mappings.ts
+var MODEL_ID_TO_ANTHROPIC_MODEL = {
+  "duo-chat-opus-4-5": "claude-opus-4-5-20251101",
+  "duo-chat-sonnet-4-5": "claude-sonnet-4-5-20250929",
+  "duo-chat-haiku-4-5": "claude-haiku-4-5-20251001"
+};
+function getAnthropicModelForModelId(modelId) {
+  return MODEL_ID_TO_ANTHROPIC_MODEL[modelId];
+}
+
 // src/gitlab-provider.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
@@ -895,9 +931,10 @@ function createGitLab(options = {}) {
       getHeaders,
       refreshApiKey,
       fetch: options.fetch,
-      anthropicModel: agenticOptions?.anthropicModel,
+      anthropicModel: agenticOptions?.anthropicModel ?? getAnthropicModelForModelId(modelId),
       maxTokens: agenticOptions?.maxTokens,
-      featureFlags
+      featureFlags,
+      aiGatewayUrl: options.aiGatewayUrl
     });
   };
   const createDefaultModel = (modelId) => {
@@ -923,1196 +960,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 {
@@ -2195,7 +1045,7 @@ var GitLabProjectCache = class {
 };
 
 // src/gitlab-project-detector.ts
-var debugLog = (..._args) => {
+var debugLog2 = (..._args) => {
 };
 var GitLabProjectDetector = class {
   config;
@@ -2218,41 +1068,41 @@ 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;
     }
     try {
-      debugLog(`[GitLabProjectDetector] Getting git remote URL from: ${workingDirectory}`);
+      debugLog2(`[GitLabProjectDetector] Getting git remote URL from: ${workingDirectory}`);
       const remoteUrl = await this.getGitRemoteUrl(workingDirectory, remoteName);
       if (!remoteUrl) {
-        debugLog(`[GitLabProjectDetector] No git remote URL found`);
+        debugLog2(`[GitLabProjectDetector] No git remote URL found`);
         return null;
       }
-      debugLog(`[GitLabProjectDetector] Git remote URL: ${remoteUrl}`);
-      debugLog(
+      debugLog2(`[GitLabProjectDetector] Git remote URL: ${remoteUrl}`);
+      debugLog2(
         `[GitLabProjectDetector] Parsing project path from URL (instance: ${this.config.instanceUrl})`
       );
       const projectPath = this.parseGitRemoteUrl(remoteUrl, this.config.instanceUrl);
       if (!projectPath) {
-        debugLog(
+        debugLog2(
           `[GitLabProjectDetector] Could not parse project path from URL (remote doesn't match instance)`
         );
         return null;
       }
-      debugLog(`[GitLabProjectDetector] Parsed project path: ${projectPath}`);
-      debugLog(`[GitLabProjectDetector] Fetching project from GitLab API: ${projectPath}`);
+      debugLog2(`[GitLabProjectDetector] Parsed project path: ${projectPath}`);
+      debugLog2(`[GitLabProjectDetector] Fetching project from GitLab API: ${projectPath}`);
       const project = await this.getProjectByPath(projectPath);
-      debugLog(`[GitLabProjectDetector] \u2713 Project fetched successfully:`, project);
+      debugLog2(`[GitLabProjectDetector] \u2713 Project fetched successfully:`, project);
       this.cache.set(cacheKey, project);
       return project;
     } catch (error) {
       if (error instanceof GitLabError) {
-        debugLog(`[GitLabProjectDetector] GitLab API error:`, error.message || error);
+        debugLog2(`[GitLabProjectDetector] GitLab API error:`, error.message || error);
         return null;
       }
-      debugLog(`[GitLabProjectDetector] Unexpected error:`, error);
+      debugLog2(`[GitLabProjectDetector] Unexpected error:`, error);
       console.warn(`Failed to auto-detect GitLab project: ${error}`);
       return null;
     }
@@ -2303,8 +1153,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
       });
@@ -2318,13 +1168,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);
       });
     });
   }
@@ -2381,21 +1231,20 @@ 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,
   GitLabProjectDetector,
+  MODEL_ID_TO_ANTHROPIC_MODEL,
   OAUTH_SCOPES,
   TOKEN_EXPIRY_SKEW_MS,
   createGitLab,
-  gitlab,
-  isGitLabApiTool
+  getAnthropicModelForModelId,
+  gitlab
 });
 //# sourceMappingURL=index.js.map