gitlab-ai-provider 5.0.0 → 5.1.1

package/dist/index.mjs

@@ -289,7 +289,8 @@ var GitLabAnthropicLanguageModel = class {
     const messages = [];
     for (const message of prompt) {
       if (message.role === "system") {
-        systemMessage = message.content;
+        systemMessage = systemMessage ? `${systemMessage}
+${message.content}` : message.content;
         continue;
       }
       if (message.role === "user") {
@@ -1505,7 +1506,7 @@ var GitLabOpenAILanguageModel = class {
 import WebSocket from "isomorphic-ws";
 
 // src/version.ts
-var VERSION = true ? "3.6.0" : "0.0.0-dev";
+var VERSION = true ? "5.1.0" : "0.0.0-dev";
 
 // src/gitlab-workflow-types.ts
 var WorkflowType = /* @__PURE__ */ ((WorkflowType2) => {
@@ -1842,7 +1843,8 @@ function sanitizeErrorMessage(message) {
   if (!message) return "";
   return message.replace(/\bBearer\s+[A-Za-z0-9\-_.~+/]+=*/gi, "Bearer [REDACTED]").replace(/\bgl(?:pat|oat|cbt|dt|oas|rt|soat|ffct|sapat)-[A-Za-z0-9_-]+/g, "[REDACTED]").replace(/([?&](?:private_token|access_token|token)=)[^&\s"']*/gi, "$1[REDACTED]").replace(/:\/\/([^:@/\s]+):([^@/\s]+)@/g, "://$1:[REDACTED]@");
 }
-function mapBuiltinTool(dwsToolName, data) {
+function mapBuiltinTool(dwsToolName, data, availableTools) {
+  const has = (name) => !availableTools || availableTools.has(name);
   switch (dwsToolName) {
     case "runReadFile":
       return { toolName: "read", args: { filePath: data.filepath } };
@@ -1856,20 +1858,51 @@ function mapBuiltinTool(dwsToolName, data) {
         args: { filePaths: paths }
       };
     }
-    case "runWriteFile":
-      return {
-        toolName: "write",
-        args: { filePath: data.filepath, content: data.contents }
-      };
-    case "runEditFile":
-      return {
-        toolName: "edit",
-        args: {
-          filePath: data.filepath,
-          oldString: data.oldString ?? data.old_string,
-          newString: data.newString ?? data.new_string
-        }
-      };
+    case "runWriteFile": {
+      if (has("write")) {
+        return {
+          toolName: "write",
+          args: { filePath: data.filepath, content: data.contents }
+        };
+      }
+      const filePath = String(data.filepath ?? "");
+      const content = String(data.contents ?? "");
+      const patchLines = [
+        "*** Begin Patch",
+        `*** Add File: ${filePath}`,
+        ...content.split("\n").map((l) => `+${l}`),
+        "*** End Patch"
+      ].join("\n");
+      return { toolName: "apply_patch", args: { patchText: patchLines } };
+    }
+    case "runEditFile": {
+      const editOldString = String(data.oldString ?? data.old_string ?? "");
+      const editNewString = String(data.newString ?? data.new_string ?? "");
+      if (has("edit")) {
+        return {
+          toolName: "edit",
+          args: {
+            filePath: data.filepath,
+            oldString: editOldString,
+            newString: editNewString
+          }
+        };
+      }
+      const editPath = String(data.filepath ?? "");
+      const oldStr = editOldString;
+      const newStr = editNewString;
+      const oldLines = oldStr.split("\n");
+      const newLines = newStr.split("\n");
+      const patchContent = [
+        "*** Begin Patch",
+        `*** Update File: ${editPath}`,
+        "@@",
+        ...oldLines.map((l) => `-${l}`),
+        ...newLines.map((l) => `+${l}`),
+        "*** End Patch"
+      ].join("\n");
+      return { toolName: "apply_patch", args: { patchText: patchContent } };
+    }
     case "runShellCommand": {
       const command = data.command;
       if (!command || typeof command !== "string") {
@@ -1992,6 +2025,87 @@ function mapBuiltinTool(dwsToolName, data) {
       return { toolName: dwsToolName, args: data };
   }
 }
+function validateSafePath(filePath) {
+  if (!filePath) {
+    throw new Error("filePath is required");
+  }
+  if (filePath.includes("\0")) {
+    throw new Error("filePath contains null bytes");
+  }
+  const path5 = __require("path");
+  const resolved = path5.resolve(filePath);
+  const cwd = process.cwd();
+  if (!resolved.startsWith(cwd + path5.sep) && resolved !== cwd) {
+    throw new Error(`filePath resolves outside the working directory: ${filePath}`);
+  }
+  return resolved;
+}
+function executeBuiltinFallback(toolName, argsJson) {
+  if (toolName !== "edit" && toolName !== "write") {
+    return null;
+  }
+  const fs4 = __require("fs");
+  let args;
+  try {
+    args = JSON.parse(argsJson);
+  } catch {
+    return { result: "", error: `${toolName} fallback: invalid JSON arguments` };
+  }
+  try {
+    if (toolName === "write") {
+      const filePath2 = String(args.filePath ?? "");
+      if (!filePath2) {
+        return { result: "", error: "write fallback: filePath is required" };
+      }
+      const safePath2 = validateSafePath(filePath2);
+      const content2 = String(args.content ?? "");
+      fs4.writeFileSync(safePath2, content2, "utf-8");
+      return {
+        result: "File written successfully.",
+        title: filePath2,
+        metadata: { output: "File written successfully." }
+      };
+    }
+    const filePath = String(args.filePath ?? "");
+    const oldString = String(args.oldString ?? "");
+    const newString = String(args.newString ?? "");
+    if (!filePath) {
+      return { result: "", error: "edit fallback: filePath is required" };
+    }
+    if (!oldString && !newString) {
+      return { result: "", error: "edit fallback: oldString and newString are both empty" };
+    }
+    const safePath = validateSafePath(filePath);
+    let content;
+    try {
+      content = fs4.readFileSync(safePath, "utf-8");
+    } catch {
+      content = "";
+    }
+    if (oldString === "") {
+      fs4.writeFileSync(safePath, newString, "utf-8");
+      return {
+        result: "Edit applied successfully.",
+        title: filePath,
+        metadata: { output: "Edit applied successfully." }
+      };
+    }
+    const idx = content.indexOf(oldString);
+    if (idx === -1) {
+      return { result: "", error: `edit fallback: could not find oldString in ${filePath}` };
+    }
+    const newContent = content.substring(0, idx) + newString + content.substring(idx + oldString.length);
+    fs4.writeFileSync(safePath, newContent, "utf-8");
+    return {
+      result: "Edit applied successfully.",
+      title: filePath,
+      metadata: { output: "Edit applied successfully." }
+    };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { result: "", error: sanitizeErrorMessage(msg) };
+  }
+}
 
 // src/gitlab-workflow-token-client.ts
 var TOKEN_CACHE_DURATION_MS = 25 * 60 * 1e3;
@@ -3082,6 +3196,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
     const preapprovedTools = this.workflowOptions.preapprovedTools ?? mcpTools.map((t) => t.name);
     const additionalContext = this.buildAdditionalContext(options.prompt);
     const toolExecutor = this.toolExecutor ?? null;
+    const availableToolNames = new Set(options.tools?.map((t) => t.name) ?? []);
     await this.tokenClient.getToken(
       this.workflowOptions.workflowDefinition ?? DEFAULT_WORKFLOW_DEFINITION,
       this.workflowOptions.rootNamespaceId
@@ -3142,7 +3257,8 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
                 controller,
                 wsClient,
                 toolExecutor,
-                () => `text-${textBlockCounter++}`
+                () => `text-${textBlockCounter++}`,
+                availableToolNames
               );
             }
           );
@@ -3223,7 +3339,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
   // ---------------------------------------------------------------------------
   // Event handling
   // ---------------------------------------------------------------------------
-  handleWorkflowEvent(ss, event, controller, wsClient, toolExecutor, nextTextId) {
+  handleWorkflowEvent(ss, event, controller, wsClient, toolExecutor, nextTextId, availableToolNames) {
     if (ss.streamClosed) {
       return;
     }
@@ -3280,7 +3396,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         break;
       }
       case "builtin-tool-request": {
-        const mapped = mapBuiltinTool(event.toolName, event.data);
+        const mapped = mapBuiltinTool(event.toolName, event.data, availableToolNames);
         const mappedArgs = JSON.stringify(mapped.args);
         if (ss.activeTextBlockId) {
           controller.enqueue({ type: "text-end", id: ss.activeTextBlockId });
@@ -3480,37 +3596,19 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
     };
     try {
       if (toolExecutor) {
-        const result = await toolExecutor(toolName, argsJson, requestID);
+        let result = await toolExecutor(toolName, argsJson, requestID);
+        if (result.error && /^Unknown tool:/.test(result.error)) {
+          const fallback = executeBuiltinFallback(toolName, argsJson);
+          if (fallback) {
+            result = fallback;
+          }
+        }
         wsClient.sendActionResponse(requestID, result.result, result.error);
         ss.streamedInputChars += argsJson.length;
         ss.streamedOutputChars += result.result.length;
-        let toolOutput = result.result;
-        let toolTitle = `${toolName} result`;
-        let toolMetadata = { output: result.result };
-        try {
-          const parsed = JSON.parse(result.result);
-          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-            if (typeof parsed.output === "string") {
-              toolOutput = parsed.output;
-            } else if (parsed.output != null) {
-              toolOutput = JSON.stringify(parsed.output);
-            }
-            if (typeof parsed.title === "string") toolTitle = parsed.title;
-            if (parsed.metadata && typeof parsed.metadata === "object") {
-              toolMetadata = {};
-              for (const [k, v] of Object.entries(parsed.metadata)) {
-                toolMetadata[k] = typeof v === "string" ? v : JSON.stringify(v);
-              }
-              if (!("output" in toolMetadata)) {
-                toolMetadata.output = toolOutput;
-              }
-            }
-          } else if (Array.isArray(parsed)) {
-            toolOutput = JSON.stringify(parsed);
-            toolMetadata = { output: toolOutput };
-          }
-        } catch {
-        }
+        const toolOutput = result.result;
+        const toolTitle = result.title ?? `${toolName} result`;
+        const toolMetadata = result.metadata ?? { output: result.result };
         if (result.error) {
           let errorText;
           if (typeof result.error === "string") {
@@ -3520,16 +3618,11 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
           } else {
             errorText = String(result.error);
           }
-          const errorOutput = toolOutput || errorText;
           safeEnqueue({
             type: "tool-result",
             toolCallId: requestID,
             toolName,
-            result: {
-              output: errorOutput,
-              title: toolTitle,
-              metadata: { ...toolMetadata, error: errorText }
-            },
+            result: errorText,
             isError: true,
             providerExecuted: true
           });
@@ -3554,11 +3647,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
           type: "tool-result",
           toolCallId: requestID,
           toolName,
-          result: {
-            output: errorMsg,
-            title: `${toolName} error`,
-            metadata: { output: errorMsg }
-          },
+          result: errorMsg,
           isError: true,
           providerExecuted: true
         });
@@ -3571,11 +3660,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         type: "tool-result",
         toolCallId: requestID,
         toolName,
-        result: {
-          output: errorMsg,
-          title: `${toolName} error`,
-          metadata: { output: errorMsg }
-        },
+        result: errorMsg,
         isError: true,
         providerExecuted: true
       });
@@ -4174,6 +4259,170 @@ function createGitLab(options = {}) {
   return provider;
 }
 var gitlab = createGitLab();
+
+// src/gitlab-model-config.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
+var DEFAULT_MODELS_YML_URL = "https://gitlab.com/gitlab-org/modelops/applied-ml/code-suggestions/ai-assist/-/raw/main/ai_gateway/model_selection/models.yml";
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_CONTEXT = 2e5;
+var DEFAULT_OUTPUT = 64e3;
+function getCacheFilePath2() {
+  const cacheHome = process.env.XDG_CACHE_HOME || path4.join(os3.homedir(), ".cache");
+  return path4.join(cacheHome, "opencode", "gitlab-model-configs.json");
+}
+function readCacheFile() {
+  try {
+    const filePath = getCacheFilePath2();
+    if (!fs3.existsSync(filePath)) return null;
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCacheFile(configs) {
+  try {
+    const filePath = getCacheFilePath2();
+    const dir = path4.dirname(filePath);
+    fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+    const data = {
+      configs: Object.fromEntries(configs),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs3.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 384 });
+  } catch {
+  }
+}
+function loadCacheFile(ttlMs) {
+  const cached = readCacheFile();
+  if (!cached) return null;
+  const writtenAt = new Date(cached.updatedAt).getTime();
+  const age = Date.now() - writtenAt;
+  if (age > ttlMs) return null;
+  return { configs: new Map(Object.entries(cached.configs)), writtenAt };
+}
+var GitLabModelConfigRegistry = class {
+  url;
+  ttlMs;
+  fetchFn;
+  memCache = null;
+  memExpiresAt = 0;
+  pending = null;
+  constructor(options) {
+    this.url = options?.url ?? DEFAULT_MODELS_YML_URL;
+    this.ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
+    this.fetchFn = options?.fetch ?? fetch;
+  }
+  /**
+   * Get model configs, fetching and caching as needed.
+   * Returns a Map keyed by `gitlab_identifier` (the discovery `ref`).
+   */
+  async getConfigs() {
+    if (this.memCache && Date.now() < this.memExpiresAt) {
+      return this.memCache;
+    }
+    const fileCached = loadCacheFile(this.ttlMs);
+    if (fileCached) {
+      this.memCache = fileCached.configs;
+      this.memExpiresAt = fileCached.writtenAt + this.ttlMs;
+      return fileCached.configs;
+    }
+    if (this.pending) return this.pending;
+    this.pending = this.fetchConfigs();
+    try {
+      return await this.pending;
+    } finally {
+      this.pending = null;
+    }
+  }
+  /**
+   * Look up config for a single model ref.
+   * Returns defaults if the ref is not found or fetch fails.
+   */
+  async getConfig(ref) {
+    const configs = await this.getConfigs();
+    return configs.get(ref) ?? { context: DEFAULT_CONTEXT, output: DEFAULT_OUTPUT };
+  }
+  /** Invalidate both in-memory and file caches. */
+  invalidateCache() {
+    this.memCache = null;
+    this.memExpiresAt = 0;
+    try {
+      const filePath = getCacheFilePath2();
+      if (fs3.existsSync(filePath)) {
+        fs3.unlinkSync(filePath);
+      }
+    } catch {
+    }
+  }
+  async fetchConfigs() {
+    try {
+      const res = await this.fetchFn(this.url);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const text = await res.text();
+      const configs = parseModelsYml(text);
+      this.memCache = configs;
+      this.memExpiresAt = Date.now() + this.ttlMs;
+      writeCacheFile(configs);
+      return configs;
+    } catch {
+      return this.memCache ?? loadCacheFile(Infinity)?.configs ?? /* @__PURE__ */ new Map();
+    }
+  }
+};
+function parseModelsYml(text) {
+  const configs = /* @__PURE__ */ new Map();
+  let currentIdentifier = null;
+  let currentContext = 0;
+  let currentOutput = 0;
+  let inParams = false;
+  let paramsIndent = -1;
+  for (const line of text.split("\n")) {
+    const idMatch = line.match(/^\s*gitlab_identifier:\s*"?([^"#\s]+)"?/);
+    if (idMatch) {
+      if (currentIdentifier) {
+        configs.set(currentIdentifier, {
+          context: currentContext || DEFAULT_CONTEXT,
+          output: currentOutput || DEFAULT_OUTPUT
+        });
+      }
+      currentIdentifier = idMatch[1];
+      currentContext = 0;
+      currentOutput = 0;
+      inParams = false;
+      paramsIndent = -1;
+    }
+    const ctxMatch = line.match(/^\s*max_context_tokens:\s*([0-9_]+)/);
+    if (ctxMatch && currentIdentifier) {
+      currentContext = parseInt(ctxMatch[1].replace(/_/g, ""), 10);
+    }
+    if (/^\s*params:\s*$/.test(line)) {
+      inParams = true;
+      paramsIndent = line.match(/^(\s*)/)?.[1].length ?? 0;
+    } else if (inParams && /^\s*\S+:/.test(line)) {
+      const indent = line.match(/^(\s*)/)?.[1].length ?? 0;
+      if (indent <= paramsIndent) {
+        inParams = false;
+        paramsIndent = -1;
+      }
+    }
+    if (inParams) {
+      const maxTokensMatch = line.match(/^\s*max_tokens:\s*([0-9_]+)/);
+      if (maxTokensMatch && currentIdentifier) {
+        currentOutput = parseInt(maxTokensMatch[1].replace(/_/g, ""), 10);
+      }
+    }
+  }
+  if (currentIdentifier) {
+    configs.set(currentIdentifier, {
+      context: currentContext || DEFAULT_CONTEXT,
+      output: currentOutput || DEFAULT_OUTPUT
+    });
+  }
+  return configs;
+}
 export {
   AGENT_PRIVILEGES,
   BUNDLED_CLIENT_ID,
@@ -4187,6 +4436,7 @@ export {
   GitLabDirectAccessClient,
   GitLabError,
   GitLabModelCache,
+  GitLabModelConfigRegistry,
   GitLabModelDiscovery,
   GitLabOAuthManager,
   GitLabOpenAILanguageModel,
@@ -4215,6 +4465,7 @@ export {
   getWorkflowModelRef,
   gitlab,
   isResponsesApiModel,
-  isWorkflowModel
+  isWorkflowModel,
+  parseModelsYml
 };
 //# sourceMappingURL=index.mjs.map