@gitlab/gitlab-ai-provider 1.0.5

package/dist/index.js

@@ -0,0 +1,2401 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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,
+  GITLAB_COM_URL: () => GITLAB_COM_URL,
+  GitLabAgenticLanguageModel: () => GitLabAgenticLanguageModel,
+  GitLabApiToolExecutor: () => GitLabApiToolExecutor,
+  GitLabError: () => GitLabError,
+  GitLabOAuthManager: () => GitLabOAuthManager,
+  GitLabProjectCache: () => GitLabProjectCache,
+  GitLabProjectDetector: () => GitLabProjectDetector,
+  OAUTH_SCOPES: () => OAUTH_SCOPES,
+  TOKEN_EXPIRY_SKEW_MS: () => TOKEN_EXPIRY_SKEW_MS,
+  createGitLab: () => createGitLab,
+  gitlab: () => gitlab,
+  isGitLabApiTool: () => isGitLabApiTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/gitlab-agentic-language-model.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+
+// src/gitlab-direct-access.ts
+var import_zod = require("zod");
+
+// src/gitlab-error.ts
+var GitLabError = class _GitLabError extends Error {
+  statusCode;
+  responseBody;
+  cause;
+  constructor(options) {
+    super(options.message);
+    this.name = "GitLabError";
+    this.statusCode = options.statusCode;
+    this.responseBody = options.responseBody;
+    this.cause = options.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _GitLabError);
+    }
+  }
+  static fromResponse(response, body) {
+    return new _GitLabError({
+      message: `GitLab API error: ${response.status} ${response.statusText}`,
+      statusCode: response.status,
+      responseBody: body
+    });
+  }
+  isAuthError() {
+    return this.statusCode === 401;
+  }
+  isRateLimitError() {
+    return this.statusCode === 429;
+  }
+  isForbiddenError() {
+    return this.statusCode === 403;
+  }
+  isServerError() {
+    return this.statusCode !== void 0 && this.statusCode >= 500;
+  }
+};
+
+// src/gitlab-direct-access.ts
+var directAccessTokenSchema = import_zod.z.object({
+  headers: import_zod.z.record(import_zod.z.string()),
+  token: import_zod.z.string()
+});
+var GitLabDirectAccessClient = class {
+  config;
+  fetchFn;
+  cachedToken = null;
+  tokenExpiresAt = 0;
+  constructor(config) {
+    this.config = config;
+    this.fetchFn = config.fetch ?? fetch;
+  }
+  /**
+   * Get a direct access token for the Anthropic proxy.
+   * Tokens are cached for 25 minutes (they expire after 30 minutes).
+   * @param forceRefresh - If true, ignores the cache and fetches a new token
+   */
+  async getDirectAccessToken(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && this.cachedToken && this.tokenExpiresAt > now) {
+      return this.cachedToken;
+    }
+    if (forceRefresh) {
+      this.invalidateToken();
+    }
+    const url = `${this.config.instanceUrl}/api/v4/ai/third_party_agents/direct_access`;
+    const requestBody = {};
+    if (this.config.featureFlags && Object.keys(this.config.featureFlags).length > 0) {
+      requestBody.feature_flags = this.config.featureFlags;
+    }
+    try {
+      const response = await this.fetchFn(url, {
+        method: "POST",
+        headers: {
+          ...this.config.getHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        if (response.status === 401 && this.config.refreshApiKey && !forceRefresh) {
+          try {
+            await this.config.refreshApiKey();
+            return await this.getDirectAccessToken(true);
+          } catch (refreshError) {
+            throw new GitLabError({
+              message: `Failed to get direct access token: ${response.status} ${response.statusText} - ${errorText}`
+            });
+          }
+        }
+        throw new GitLabError({
+          message: `Failed to get direct access token: ${response.status} ${response.statusText} - ${errorText}`
+        });
+      }
+      const data = await response.json();
+      const token = directAccessTokenSchema.parse(data);
+      this.cachedToken = token;
+      this.tokenExpiresAt = now + 25 * 60 * 1e3;
+      return token;
+    } catch (error) {
+      if (error instanceof GitLabError) {
+        throw error;
+      }
+      throw new GitLabError({
+        message: `Failed to get direct access token: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get the Anthropic proxy base URL
+   */
+  getAnthropicProxyUrl() {
+    return "https://cloud.gitlab.com/ai/v1/proxy/anthropic/";
+  }
+  /**
+   * Invalidate the cached token
+   */
+  invalidateToken() {
+    this.cachedToken = null;
+    this.tokenExpiresAt = 0;
+  }
+};
+
+// src/gitlab-agentic-language-model.ts
+var GitLabAgenticLanguageModel = class {
+  specificationVersion = "v2";
+  modelId;
+  supportedUrls = {};
+  config;
+  directAccessClient;
+  anthropicClient = null;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.directAccessClient = new GitLabDirectAccessClient({
+      instanceUrl: config.instanceUrl,
+      getHeaders: config.getHeaders,
+      refreshApiKey: config.refreshApiKey,
+      fetch: config.fetch,
+      featureFlags: config.featureFlags
+    });
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  /**
+   * Get or create an Anthropic client with valid credentials
+   * @param forceRefresh - If true, forces a token refresh before creating the client
+   */
+  async getAnthropicClient(forceRefresh = false) {
+    const tokenData = await this.directAccessClient.getDirectAccessToken(forceRefresh);
+    this.anthropicClient = new import_sdk.default({
+      authToken: tokenData.token,
+      baseURL: this.directAccessClient.getAnthropicProxyUrl(),
+      defaultHeaders: tokenData.headers
+    });
+    return this.anthropicClient;
+  }
+  /**
+   * Check if an error is a token-related authentication error that can be retried
+   */
+  isTokenError(error) {
+    if (error instanceof import_sdk.default.APIError) {
+      if (error.status === 401) {
+        return true;
+      }
+      const message = error.message?.toLowerCase() || "";
+      if (message.includes("token") && (message.includes("expired") || message.includes("revoked") || message.includes("invalid"))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Convert AI SDK tools to Anthropic tool format
+   */
+  convertTools(tools) {
+    if (!tools || tools.length === 0) {
+      return void 0;
+    }
+    return tools.filter((tool) => tool.type === "function").map((tool) => {
+      const schema = tool.inputSchema;
+      return {
+        name: tool.name,
+        description: tool.description || "",
+        input_schema: {
+          type: "object",
+          properties: schema?.properties || {},
+          required: schema?.required || []
+        }
+      };
+    });
+  }
+  /**
+   * Convert AI SDK tool choice to Anthropic format
+   */
+  convertToolChoice(toolChoice) {
+    if (!toolChoice) {
+      return void 0;
+    }
+    switch (toolChoice.type) {
+      case "auto":
+        return { type: "auto" };
+      case "none":
+        return void 0;
+      case "required":
+        return { type: "any" };
+      case "tool":
+        return { type: "tool", name: toolChoice.toolName };
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * Convert AI SDK prompt to Anthropic messages format
+   */
+  convertPrompt(prompt) {
+    let systemMessage;
+    const messages = [];
+    for (const message of prompt) {
+      if (message.role === "system") {
+        systemMessage = message.content;
+        continue;
+      }
+      if (message.role === "user") {
+        const content = [];
+        for (const part of message.content) {
+          if (part.type === "text") {
+            content.push({ type: "text", text: part.text });
+          } else if (part.type === "file") {
+          }
+        }
+        if (content.length > 0) {
+          messages.push({ role: "user", content });
+        }
+      } else if (message.role === "assistant") {
+        const content = [];
+        for (const part of message.content) {
+          if (part.type === "text") {
+            content.push({ type: "text", text: part.text });
+          } else if (part.type === "tool-call") {
+            content.push({
+              type: "tool_use",
+              id: part.toolCallId,
+              name: part.toolName,
+              input: typeof part.input === "string" ? JSON.parse(part.input) : part.input
+            });
+          }
+        }
+        if (content.length > 0) {
+          messages.push({ role: "assistant", content });
+        }
+      } else if (message.role === "tool") {
+        const content = [];
+        for (const part of message.content) {
+          if (part.type === "tool-result") {
+            let resultContent;
+            if (part.output.type === "text") {
+              resultContent = part.output.value;
+            } else if (part.output.type === "json") {
+              resultContent = JSON.stringify(part.output.value);
+            } else if (part.output.type === "error-text") {
+              resultContent = part.output.value;
+            } else if (part.output.type === "error-json") {
+              resultContent = JSON.stringify(part.output.value);
+            } else {
+              resultContent = JSON.stringify(part.output);
+            }
+            content.push({
+              type: "tool_result",
+              tool_use_id: part.toolCallId,
+              content: resultContent,
+              is_error: part.output.type.startsWith("error")
+            });
+          }
+        }
+        if (content.length > 0) {
+          messages.push({ role: "user", content });
+        }
+      }
+    }
+    return { system: systemMessage, messages };
+  }
+  /**
+   * Convert Anthropic finish reason to AI SDK format
+   */
+  convertFinishReason(stopReason) {
+    switch (stopReason) {
+      case "end_turn":
+        return "stop";
+      case "stop_sequence":
+        return "stop";
+      case "max_tokens":
+        return "length";
+      case "tool_use":
+        return "tool-calls";
+      default:
+        return "unknown";
+    }
+  }
+  async doGenerate(options) {
+    return this.doGenerateWithRetry(options, false);
+  }
+  async doGenerateWithRetry(options, isRetry) {
+    const client = await this.getAnthropicClient(isRetry);
+    const { system, messages } = this.convertPrompt(options.prompt);
+    const tools = this.convertTools(options.tools);
+    const toolChoice = options.toolChoice?.type !== "none" ? this.convertToolChoice(options.toolChoice) : void 0;
+    const anthropicModel = this.config.anthropicModel || "claude-sonnet-4-5-20250929";
+    const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    try {
+      const response = await client.messages.create({
+        model: anthropicModel,
+        max_tokens: maxTokens,
+        system,
+        messages,
+        tools,
+        tool_choice: tools ? toolChoice : void 0,
+        temperature: options.temperature,
+        top_p: options.topP,
+        stop_sequences: options.stopSequences
+      });
+      const content = [];
+      for (const block of response.content) {
+        if (block.type === "text") {
+          content.push({
+            type: "text",
+            text: block.text
+          });
+        } else if (block.type === "tool_use") {
+          content.push({
+            type: "tool-call",
+            toolCallId: block.id,
+            toolName: block.name,
+            input: JSON.stringify(block.input)
+          });
+        }
+      }
+      const usage = {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens
+      };
+      return {
+        content,
+        finishReason: this.convertFinishReason(response.stop_reason),
+        usage,
+        warnings: []
+      };
+    } catch (error) {
+      if (!isRetry && this.isTokenError(error)) {
+        this.directAccessClient.invalidateToken();
+        return this.doGenerateWithRetry(options, true);
+      }
+      if (error instanceof import_sdk.default.APIError) {
+        throw new GitLabError({
+          message: `Anthropic API error: ${error.message}`,
+          cause: error
+        });
+      }
+      throw error;
+    }
+  }
+  async doStream(options) {
+    return this.doStreamWithRetry(options, false);
+  }
+  async doStreamWithRetry(options, isRetry) {
+    const client = await this.getAnthropicClient(isRetry);
+    const { system, messages } = this.convertPrompt(options.prompt);
+    const tools = this.convertTools(options.tools);
+    const toolChoice = options.toolChoice?.type !== "none" ? this.convertToolChoice(options.toolChoice) : void 0;
+    const anthropicModel = this.config.anthropicModel || "claude-sonnet-4-5-20250929";
+    const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    const requestBody = {
+      model: anthropicModel,
+      max_tokens: maxTokens,
+      system,
+      messages,
+      tools,
+      tool_choice: tools ? toolChoice : void 0,
+      temperature: options.temperature,
+      top_p: options.topP,
+      stop_sequences: options.stopSequences,
+      stream: true
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        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";
+          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") {
+                    controller.enqueue({
+                      type: "tool-call",
+                      toolCallId: block.id,
+                      toolName: block.name,
+                      input: JSON.stringify(block.input)
+                    });
+                  }
+                }
+                controller.enqueue({
+                  type: "finish",
+                  finishReason,
+                  usage
+                });
+                break;
+              }
+            }
+          }
+          controller.close();
+        } catch (error) {
+          if (!isRetry && self.isTokenError(error)) {
+            self.directAccessClient.invalidateToken();
+            controller.enqueue({
+              type: "error",
+              error: new GitLabError({
+                message: "TOKEN_REFRESH_NEEDED",
+                cause: error
+              })
+            });
+            controller.close();
+            return;
+          }
+          if (error instanceof import_sdk.default.APIError) {
+            controller.enqueue({
+              type: "error",
+              error: new GitLabError({
+                message: `Anthropic API error: ${error.message}`,
+                cause: error
+              })
+            });
+          } else {
+            controller.enqueue({
+              type: "error",
+              error
+            });
+          }
+          controller.close();
+        }
+      }
+    });
+    return {
+      stream,
+      request: { body: requestBody }
+    };
+  }
+};
+
+// src/gitlab-oauth-types.ts
+var BUNDLED_CLIENT_ID = "36f2a70cddeb5a0889d4fd8295c241b7e9848e89cf9e599d0eed2d8e5350fbf5";
+var GITLAB_COM_URL = "https://gitlab.com";
+var TOKEN_EXPIRY_SKEW_MS = 5 * 60 * 1e3;
+var OAUTH_SCOPES = ["api"];
+
+// src/gitlab-oauth-manager.ts
+var GitLabOAuthManager = class {
+  fetch;
+  constructor(fetchImpl = fetch) {
+    this.fetch = fetchImpl;
+  }
+  /**
+   * Check if a token is expired
+   */
+  isTokenExpired(expiresAt) {
+    return Date.now() >= expiresAt;
+  }
+  /**
+   * Check if a token needs refresh (within skew window)
+   */
+  needsRefresh(expiresAt) {
+    return Date.now() >= expiresAt - TOKEN_EXPIRY_SKEW_MS;
+  }
+  /**
+   * Refresh tokens if needed
+   * Returns the same tokens if refresh is not needed, or new tokens if refreshed
+   */
+  async refreshIfNeeded(tokens, clientId) {
+    if (!this.needsRefresh(tokens.expiresAt)) {
+      return tokens;
+    }
+    if (this.isTokenExpired(tokens.expiresAt)) {
+      throw new GitLabError({
+        message: "OAuth token has expired and cannot be used"
+      });
+    }
+    return this.exchangeRefreshToken({
+      instanceUrl: tokens.instanceUrl,
+      refreshToken: tokens.refreshToken,
+      clientId
+    });
+  }
+  /**
+   * Exchange authorization code for tokens
+   * Based on gitlab-vscode-extension createOAuthAccountFromCode
+   */
+  async exchangeAuthorizationCode(params) {
+    const { instanceUrl, code, codeVerifier, clientId, redirectUri } = params;
+    const tokenResponse = await this.exchangeToken({
+      instanceUrl,
+      grantType: "authorization_code",
+      code,
+      codeVerifier,
+      clientId: clientId || this.getClientId(instanceUrl),
+      redirectUri
+    });
+    return this.createTokensFromResponse(tokenResponse, instanceUrl);
+  }
+  /**
+   * Exchange refresh token for new tokens
+   * Based on gitlab-vscode-extension TokenExchangeService
+   */
+  async exchangeRefreshToken(params) {
+    const { instanceUrl, refreshToken, clientId } = params;
+    const tokenResponse = await this.exchangeToken({
+      instanceUrl,
+      grantType: "refresh_token",
+      refreshToken,
+      clientId: clientId || this.getClientId(instanceUrl)
+    });
+    return this.createTokensFromResponse(tokenResponse, instanceUrl);
+  }
+  /**
+   * Get the OAuth client ID for an instance
+   */
+  getClientId(instanceUrl) {
+    if (instanceUrl === GITLAB_COM_URL) {
+      return BUNDLED_CLIENT_ID;
+    }
+    throw new GitLabError({
+      message: `No OAuth client ID configured for instance ${instanceUrl}. Please provide a clientId parameter.`
+    });
+  }
+  /**
+   * Exchange token with GitLab OAuth endpoint
+   * Based on gitlab-vscode-extension GitLabService.exchangeToken
+   */
+  async exchangeToken(params) {
+    const { instanceUrl, grantType, code, codeVerifier, refreshToken, clientId, redirectUri } = params;
+    const body = {
+      client_id: clientId,
+      grant_type: grantType
+    };
+    if (grantType === "authorization_code") {
+      if (!code || !codeVerifier || !redirectUri) {
+        throw new GitLabError({
+          message: "Authorization code, code verifier, and redirect URI are required for authorization_code grant"
+        });
+      }
+      body.code = code;
+      body.code_verifier = codeVerifier;
+      body.redirect_uri = redirectUri;
+    } else if (grantType === "refresh_token") {
+      if (!refreshToken) {
+        throw new GitLabError({
+          message: "Refresh token is required for refresh_token grant"
+        });
+      }
+      body.refresh_token = refreshToken;
+    }
+    const url = `${instanceUrl}/oauth/token`;
+    try {
+      const response = await this.fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: new URLSearchParams(body).toString()
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new GitLabError({
+          message: `OAuth token exchange failed: ${response.status} ${response.statusText}`,
+          cause: new Error(errorText)
+        });
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error instanceof GitLabError) {
+        throw error;
+      }
+      throw new GitLabError({
+        message: `Failed to exchange OAuth token: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error instanceof Error ? error : void 0
+      });
+    }
+  }
+  /**
+   * Create GitLabOAuthTokens from token response
+   */
+  createTokensFromResponse(response, instanceUrl) {
+    const expiresAt = this.createExpiresTimestamp(response);
+    return {
+      accessToken: response.access_token,
+      refreshToken: response.refresh_token || "",
+      expiresAt,
+      instanceUrl
+    };
+  }
+  /**
+   * Create expiry timestamp from token response
+   * Based on gitlab-vscode-extension createExpiresTimestamp
+   */
+  createExpiresTimestamp(response) {
+    const createdAt = response.created_at * 1e3;
+    const expiresIn = response.expires_in * 1e3;
+    return createdAt + expiresIn;
+  }
+};
+
+// src/gitlab-provider.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var VERSION = "0.0.1";
+function getOpenCodeAuthPath() {
+  const homeDir = os.homedir();
+  const xdgDataHome = process.env.XDG_DATA_HOME;
+  if (xdgDataHome) {
+    return path.join(xdgDataHome, "opencode", "auth.json");
+  }
+  if (process.platform !== "win32") {
+    return path.join(homeDir, ".local", "share", "opencode", "auth.json");
+  }
+  return path.join(homeDir, ".opencode", "auth.json");
+}
+async function loadOpenCodeAuth(instanceUrl) {
+  try {
+    const authPath = getOpenCodeAuthPath();
+    if (!fs.existsSync(authPath)) {
+      return void 0;
+    }
+    const authData = JSON.parse(fs.readFileSync(authPath, "utf-8"));
+    if (authData.gitlab?.type === "oauth") {
+      const gitlabAuth = authData.gitlab;
+      if (gitlabAuth.enterpriseUrl === instanceUrl || gitlabAuth.enterpriseUrl === instanceUrl.replace(/\/$/, "")) {
+        return gitlabAuth;
+      }
+    }
+    const normalizedUrl = instanceUrl.replace(/\/$/, "");
+    const auth = authData[normalizedUrl] || authData[`${normalizedUrl}/`];
+    return auth;
+  } catch (error) {
+    return void 0;
+  }
+}
+async function loadApiKey(options, instanceUrl, clientId) {
+  if (options.apiKey) {
+    return options.apiKey;
+  }
+  const auth = await loadOpenCodeAuth(instanceUrl);
+  if (auth?.type === "oauth") {
+    const oauthManager = new GitLabOAuthManager();
+    if (oauthManager.needsRefresh(auth.expires)) {
+      try {
+        const refreshed = await oauthManager.exchangeRefreshToken({
+          instanceUrl,
+          refreshToken: auth.refresh,
+          clientId
+        });
+        const authPath = getOpenCodeAuthPath();
+        const authData = JSON.parse(fs.readFileSync(authPath, "utf-8"));
+        const normalizedUrl = instanceUrl.replace(/\/$/, "");
+        authData[normalizedUrl] = {
+          type: "oauth",
+          refresh: refreshed.refreshToken,
+          access: refreshed.accessToken,
+          expires: refreshed.expiresAt,
+          instanceUrl
+        };
+        fs.writeFileSync(authPath, JSON.stringify(authData, null, 2));
+        return refreshed.accessToken;
+      } catch (error) {
+        console.warn(
+          `Failed to refresh OAuth token: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    } else {
+      return auth.access;
+    }
+  }
+  const apiKey = process.env[options.environmentVariableName];
+  if (!apiKey) {
+    throw new GitLabError({
+      message: `${options.description} API key is missing. Pass it as the 'apiKey' parameter, set the ${options.environmentVariableName} environment variable, or authenticate with 'opencode auth login gitlab'.`
+    });
+  }
+  return apiKey;
+}
+function withUserAgentSuffix(headers, suffix) {
+  const userAgent = headers["User-Agent"];
+  return {
+    ...headers,
+    "User-Agent": userAgent ? `${userAgent} ${suffix}` : suffix
+  };
+}
+function createGitLab(options = {}) {
+  const instanceUrl = options.instanceUrl ?? "https://gitlab.com";
+  const providerName = options.name ?? "gitlab";
+  let cachedApiKey;
+  let apiKeyPromise;
+  const getApiKey = async () => {
+    if (cachedApiKey) {
+      return cachedApiKey;
+    }
+    if (apiKeyPromise) {
+      return apiKeyPromise;
+    }
+    apiKeyPromise = loadApiKey(
+      {
+        apiKey: options.apiKey,
+        environmentVariableName: "GITLAB_TOKEN",
+        description: "GitLab"
+      },
+      instanceUrl,
+      options.clientId
+    );
+    cachedApiKey = await apiKeyPromise;
+    apiKeyPromise = void 0;
+    return cachedApiKey;
+  };
+  const refreshApiKey = async () => {
+    cachedApiKey = void 0;
+    apiKeyPromise = void 0;
+    cachedApiKey = await getApiKey();
+  };
+  const getHeaders = () => {
+    const apiKey = cachedApiKey || options.apiKey || process.env["GITLAB_TOKEN"] || "";
+    if (!apiKey) {
+      throw new GitLabError({
+        message: "GitLab API key is missing. Pass it as the 'apiKey' parameter, set the GITLAB_TOKEN environment variable, or authenticate with 'opencode auth login gitlab'."
+      });
+    }
+    return withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        ...options.headers
+      },
+      `ai-sdk-gitlab/${VERSION}`
+    );
+  };
+  getApiKey().catch(() => {
+  });
+  const createAgenticChatModel = (modelId, agenticOptions) => {
+    const featureFlags = {
+      DuoAgentPlatformNext: true,
+      ...options.featureFlags,
+      ...agenticOptions?.featureFlags
+    };
+    return new GitLabAgenticLanguageModel(modelId, {
+      provider: `${providerName}.agentic`,
+      instanceUrl,
+      getHeaders,
+      refreshApiKey,
+      fetch: options.fetch,
+      anthropicModel: agenticOptions?.anthropicModel,
+      maxTokens: agenticOptions?.maxTokens,
+      featureFlags
+    });
+  };
+  const createDefaultModel = (modelId) => {
+    return createAgenticChatModel(modelId);
+  };
+  const provider = Object.assign((modelId) => createDefaultModel(modelId), {
+    specificationVersion: "v2",
+    languageModel: createDefaultModel,
+    chat: createDefaultModel,
+    agenticChat: createAgenticChatModel
+  });
+  provider.textEmbeddingModel = (modelId) => {
+    throw new GitLabError({
+      message: `GitLab provider does not support text embedding models. Model ID: ${modelId}`
+    });
+  };
+  provider.imageModel = (modelId) => {
+    throw new GitLabError({
+      message: `GitLab provider does not support image models. Model ID: ${modelId}`
+    });
+  };
+  return provider;
+}
+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"));
+
+// src/gitlab-project-cache.ts
+var GitLabProjectCache = class {
+  cache = /* @__PURE__ */ new Map();
+  defaultTTL;
+  /**
+   * Create a new project cache
+   * @param defaultTTL - Default time-to-live in milliseconds (default: 5 minutes)
+   */
+  constructor(defaultTTL = 5 * 60 * 1e3) {
+    this.defaultTTL = defaultTTL;
+  }
+  /**
+   * Get a cached project by key
+   * @param key - Cache key (typically the working directory path)
+   * @returns The cached project or null if not found or expired
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.project;
+  }
+  /**
+   * Store a project in the cache
+   * @param key - Cache key (typically the working directory path)
+   * @param project - The project to cache
+   * @param ttl - Optional custom TTL in milliseconds
+   */
+  set(key, project, ttl) {
+    this.cache.set(key, {
+      project,
+      expiresAt: Date.now() + (ttl ?? this.defaultTTL)
+    });
+  }
+  /**
+   * Check if a key exists in the cache (and is not expired)
+   * @param key - Cache key to check
+   * @returns true if the key exists and is not expired
+   */
+  has(key) {
+    return this.get(key) !== null;
+  }
+  /**
+   * Remove a specific entry from the cache
+   * @param key - Cache key to remove
+   */
+  delete(key) {
+    this.cache.delete(key);
+  }
+  /**
+   * Clear all entries from the cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get the number of entries in the cache (including expired ones)
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Clean up expired entries from the cache
+   * This is useful for long-running processes to prevent memory leaks
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.expiresAt) {
+        this.cache.delete(key);
+      }
+    }
+  }
+};
+
+// src/gitlab-project-detector.ts
+var debugLog = (..._args) => {
+};
+var GitLabProjectDetector = class {
+  config;
+  fetchFn;
+  cache;
+  constructor(config) {
+    this.config = {
+      gitTimeout: 5e3,
+      // 5 seconds default
+      ...config
+    };
+    this.fetchFn = config.fetch ?? fetch;
+    this.cache = config.cache ?? new GitLabProjectCache();
+  }
+  /**
+   * Auto-detect GitLab project from git remote in the working directory
+   *
+   * @param workingDirectory - The directory to check for git remote
+   * @param remoteName - The git remote name to use (default: 'origin')
+   * @returns The detected project or null if detection fails
+   */
+  async detectProject(workingDirectory, remoteName = "origin") {
+    const cacheKey = path3.resolve(workingDirectory);
+    const cached = this.cache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    try {
+      debugLog(`[GitLabProjectDetector] Getting git remote URL from: ${workingDirectory}`);
+      const remoteUrl = await this.getGitRemoteUrl(workingDirectory, remoteName);
+      if (!remoteUrl) {
+        debugLog(`[GitLabProjectDetector] No git remote URL found`);
+        return null;
+      }
+      debugLog(`[GitLabProjectDetector] Git remote URL: ${remoteUrl}`);
+      debugLog(
+        `[GitLabProjectDetector] Parsing project path from URL (instance: ${this.config.instanceUrl})`
+      );
+      const projectPath = this.parseGitRemoteUrl(remoteUrl, this.config.instanceUrl);
+      if (!projectPath) {
+        debugLog(
+          `[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}`);
+      const project = await this.getProjectByPath(projectPath);
+      debugLog(`[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);
+        return null;
+      }
+      debugLog(`[GitLabProjectDetector] Unexpected error:`, error);
+      console.warn(`Failed to auto-detect GitLab project: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Parse a git remote URL to extract the project path
+   *
+   * Supports:
+   * - SSH: git@gitlab.com:namespace/project.git
+   * - HTTPS: https://gitlab.com/namespace/project.git
+   * - HTTP: http://gitlab.local/namespace/project.git
+   * - Custom domains and ports
+   *
+   * @param remoteUrl - The git remote URL
+   * @param instanceUrl - The GitLab instance URL to match against
+   * @returns The project path (e.g., "namespace/project") or null if parsing fails
+   */
+  parseGitRemoteUrl(remoteUrl, instanceUrl) {
+    try {
+      const instanceHost = new URL(instanceUrl).hostname;
+      const sshMatch = remoteUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+      if (sshMatch) {
+        const [, host, pathPart] = sshMatch;
+        const hostWithoutPort = host.split(":")[0];
+        if (hostWithoutPort === instanceHost) {
+          const cleanPath = pathPart.replace(/^\d+\//, "");
+          return cleanPath.endsWith(".git") ? cleanPath.slice(0, -4) : cleanPath;
+        }
+      }
+      const httpsMatch = remoteUrl.match(/^(https?):\/\/([^/]+)\/(.+?)(?:\.git)?$/);
+      if (httpsMatch) {
+        const [, , hostWithPort, pathPart] = httpsMatch;
+        const host = hostWithPort.split(":")[0];
+        if (host === instanceHost) {
+          return pathPart.endsWith(".git") ? pathPart.slice(0, -4) : pathPart;
+        }
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Get the git remote URL from a working directory
+   *
+   * @param workingDirectory - The directory to check
+   * @param remoteName - The git remote name (default: 'origin')
+   * @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`], {
+        cwd: workingDirectory,
+        timeout: this.config.gitTimeout
+      });
+      let stdout = "";
+      let _stderr = "";
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        _stderr += data.toString();
+      });
+      child.on("close", (exitCode) => {
+        if (exitCode === 0 && stdout.trim()) {
+          resolve3(stdout.trim());
+        } else {
+          resolve3(null);
+        }
+      });
+      child.on("error", () => {
+        resolve3(null);
+      });
+    });
+  }
+  /**
+   * Fetch project details from GitLab API by project path
+   *
+   * @param projectPath - The project path (e.g., "namespace/project")
+   * @returns The project details
+   * @throws GitLabError if the API call fails
+   */
+  async getProjectByPath(projectPath) {
+    const encodedPath = encodeURIComponent(projectPath);
+    const url = `${this.config.instanceUrl}/api/v4/projects/${encodedPath}`;
+    try {
+      const response = await this.fetchFn(url, {
+        method: "GET",
+        headers: this.config.getHeaders()
+      });
+      if (!response.ok) {
+        throw new GitLabError({
+          message: `Failed to fetch project '${projectPath}': ${response.status} ${response.statusText}`
+        });
+      }
+      const data = await response.json();
+      return {
+        id: data.id,
+        path: data.path,
+        pathWithNamespace: data.path_with_namespace,
+        name: data.name,
+        namespaceId: data.namespace?.id
+      };
+    } catch (error) {
+      if (error instanceof GitLabError) {
+        throw error;
+      }
+      throw new GitLabError({
+        message: `Failed to fetch project '${projectPath}': ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Clear the project cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get the cache instance (useful for testing)
+   */
+  getCache() {
+    return this.cache;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANTHROPIC_TOOLS,
+  AnthropicToolExecutor,
+  BUNDLED_CLIENT_ID,
+  GITLAB_API_TOOLS,
+  GITLAB_COM_URL,
+  GitLabAgenticLanguageModel,
+  GitLabApiToolExecutor,
+  GitLabError,
+  GitLabOAuthManager,
+  GitLabProjectCache,
+  GitLabProjectDetector,
+  OAUTH_SCOPES,
+  TOKEN_EXPIRY_SKEW_MS,
+  createGitLab,
+  gitlab,
+  isGitLabApiTool
+});
+//# sourceMappingURL=index.js.map