@gitlab/gitlab-ai-provider 3.1.2 → 3.1.3

package/dist/index.mjs

@@ -143,8 +143,6 @@ var GitLabDirectAccessClient = class {
 };
 
 // src/gitlab-agentic-language-model.ts
-var debugLog = (..._args) => {
-};
 var GitLabAgenticLanguageModel = class {
   specificationVersion = "v2";
   modelId;
@@ -173,14 +171,7 @@ var GitLabAgenticLanguageModel = class {
    */
   async getAnthropicClient(forceRefresh = false) {
     const tokenData = await this.directAccessClient.getDirectAccessToken(forceRefresh);
-    debugLog("[gitlab-ai-provider] Token headers from GitLab:", tokenData.headers);
-    debugLog("[gitlab-ai-provider] Proxy URL:", this.directAccessClient.getAnthropicProxyUrl());
     const { "x-api-key": _removed, ...filteredHeaders } = tokenData.headers;
-    if (_removed) {
-      debugLog(
-        "[gitlab-ai-provider] Filtered out x-api-key from headers (using authToken instead)"
-      );
-    }
     this.anthropicClient = new Anthropic({
       apiKey: null,
       authToken: tokenData.token,
@@ -419,114 +410,155 @@ var GitLabAgenticLanguageModel = class {
     const self = this;
     const stream = new ReadableStream({
       start: async (controller) => {
+        const contentBlocks = {};
+        const usage = {
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0
+        };
+        let finishReason = "unknown";
         try {
-          const anthropicStream = client.messages.stream(requestBody);
-          let currentTextBlockId = null;
-          let currentToolBlockId = null;
-          let currentToolName = null;
-          const usage = {
-            inputTokens: 0,
-            outputTokens: 0,
-            totalTokens: 0
-          };
-          let finishReason = "unknown";
+          const anthropicStream = client.messages.stream(requestBody, {
+            signal: options.abortSignal
+          });
           controller.enqueue({
             type: "stream-start",
             warnings: []
           });
-          for await (const event of anthropicStream) {
-            switch (event.type) {
-              case "message_start":
-                if (event.message.usage) {
-                  usage.inputTokens = event.message.usage.input_tokens;
-                }
-                controller.enqueue({
-                  type: "response-metadata",
-                  id: event.message.id,
-                  modelId: event.message.model
-                });
-                break;
-              case "content_block_start":
-                if (event.content_block.type === "text") {
-                  currentTextBlockId = `text-${event.index}`;
-                  controller.enqueue({
-                    type: "text-start",
-                    id: currentTextBlockId
-                  });
-                } else if (event.content_block.type === "tool_use") {
-                  currentToolBlockId = event.content_block.id;
-                  currentToolName = event.content_block.name;
-                  controller.enqueue({
-                    type: "tool-input-start",
-                    id: currentToolBlockId,
-                    toolName: currentToolName
-                  });
-                }
-                break;
-              case "content_block_delta":
-                if (event.delta.type === "text_delta" && currentTextBlockId) {
-                  controller.enqueue({
-                    type: "text-delta",
-                    id: currentTextBlockId,
-                    delta: event.delta.text
-                  });
-                } else if (event.delta.type === "input_json_delta" && currentToolBlockId) {
-                  controller.enqueue({
-                    type: "tool-input-delta",
-                    id: currentToolBlockId,
-                    delta: event.delta.partial_json
-                  });
-                }
-                break;
-              case "content_block_stop":
-                if (currentTextBlockId) {
-                  controller.enqueue({
-                    type: "text-end",
-                    id: currentTextBlockId
-                  });
-                  currentTextBlockId = null;
-                }
-                if (currentToolBlockId) {
-                  controller.enqueue({
-                    type: "tool-input-end",
-                    id: currentToolBlockId
-                  });
-                  currentToolBlockId = null;
-                  currentToolName = null;
-                }
-                break;
-              case "message_delta":
-                if (event.usage) {
-                  usage.outputTokens = event.usage.output_tokens;
-                  usage.totalTokens = (usage.inputTokens || 0) + event.usage.output_tokens;
-                }
-                if (event.delta.stop_reason) {
-                  finishReason = self.convertFinishReason(event.delta.stop_reason);
-                }
-                break;
-              case "message_stop": {
-                const finalMessage = await anthropicStream.finalMessage();
-                for (const block of finalMessage.content) {
-                  if (block.type === "tool_use") {
+          await new Promise((resolve2, reject) => {
+            anthropicStream.on("streamEvent", (event) => {
+              try {
+                switch (event.type) {
+                  case "message_start":
+                    if (event.message.usage) {
+                      usage.inputTokens = event.message.usage.input_tokens;
+                    }
                     controller.enqueue({
-                      type: "tool-call",
-                      toolCallId: block.id,
-                      toolName: block.name,
-                      input: JSON.stringify(block.input)
+                      type: "response-metadata",
+                      id: event.message.id,
+                      modelId: event.message.model
                     });
+                    break;
+                  case "content_block_start":
+                    if (event.content_block.type === "text") {
+                      const textId = `text-${event.index}`;
+                      contentBlocks[event.index] = { type: "text", id: textId };
+                      controller.enqueue({
+                        type: "text-start",
+                        id: textId
+                      });
+                    } else if (event.content_block.type === "tool_use") {
+                      contentBlocks[event.index] = {
+                        type: "tool-call",
+                        toolCallId: event.content_block.id,
+                        toolName: event.content_block.name,
+                        input: ""
+                      };
+                      controller.enqueue({
+                        type: "tool-input-start",
+                        id: event.content_block.id,
+                        toolName: event.content_block.name
+                      });
+                    }
+                    break;
+                  case "content_block_delta": {
+                    const block = contentBlocks[event.index];
+                    if (event.delta.type === "text_delta" && block?.type === "text") {
+                      controller.enqueue({
+                        type: "text-delta",
+                        id: block.id,
+                        delta: event.delta.text
+                      });
+                    } else if (event.delta.type === "input_json_delta" && block?.type === "tool-call") {
+                      block.input += event.delta.partial_json;
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        id: block.toolCallId,
+                        delta: event.delta.partial_json
+                      });
+                    }
+                    break;
+                  }
+                  case "content_block_stop": {
+                    const block = contentBlocks[event.index];
+                    if (block?.type === "text") {
+                      controller.enqueue({
+                        type: "text-end",
+                        id: block.id
+                      });
+                    } else if (block?.type === "tool-call") {
+                      controller.enqueue({
+                        type: "tool-input-end",
+                        id: block.toolCallId
+                      });
+                      controller.enqueue({
+                        type: "tool-call",
+                        toolCallId: block.toolCallId,
+                        toolName: block.toolName,
+                        input: block.input === "" ? "{}" : block.input
+                      });
+                    }
+                    delete contentBlocks[event.index];
+                    break;
+                  }
+                  case "message_delta":
+                    if (event.usage) {
+                      usage.outputTokens = event.usage.output_tokens;
+                      usage.totalTokens = (usage.inputTokens || 0) + event.usage.output_tokens;
+                    }
+                    if (event.delta.stop_reason) {
+                      finishReason = self.convertFinishReason(event.delta.stop_reason);
+                    }
+                    break;
+                  case "message_stop": {
+                    controller.enqueue({
+                      type: "finish",
+                      finishReason,
+                      usage
+                    });
+                    break;
                   }
                 }
-                controller.enqueue({
-                  type: "finish",
-                  finishReason,
-                  usage
-                });
-                break;
+              } catch {
               }
+            });
+            anthropicStream.on("end", () => {
+              resolve2();
+            });
+            anthropicStream.on("error", (error) => {
+              reject(error);
+            });
+          });
+          for (const [, block] of Object.entries(contentBlocks)) {
+            if (block.type === "tool-call") {
+              controller.enqueue({
+                type: "tool-input-end",
+                id: block.toolCallId
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: block.toolCallId,
+                toolName: block.toolName,
+                input: block.input === "" ? "{}" : block.input
+              });
             }
           }
           controller.close();
         } catch (error) {
+          for (const [, block] of Object.entries(contentBlocks)) {
+            if (block.type === "tool-call") {
+              controller.enqueue({
+                type: "tool-input-end",
+                id: block.toolCallId
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: block.toolCallId,
+                toolName: block.toolName,
+                input: block.input === "" ? "{}" : block.input
+              });
+            }
+          }
           if (!isRetry && self.isTokenError(error)) {
             self.directAccessClient.invalidateToken();
             controller.enqueue({
@@ -996,7 +1028,7 @@ var GitLabProjectCache = class {
 };
 
 // src/gitlab-project-detector.ts
-var debugLog2 = (..._args) => {
+var debugLog = (..._args) => {
 };
 var GitLabProjectDetector = class {
   config;
@@ -1025,35 +1057,35 @@ var GitLabProjectDetector = class {
       return cached;
     }
     try {
-      debugLog2(`[GitLabProjectDetector] Getting git remote URL from: ${workingDirectory}`);
+      debugLog(`[GitLabProjectDetector] Getting git remote URL from: ${workingDirectory}`);
       const remoteUrl = await this.getGitRemoteUrl(workingDirectory, remoteName);
       if (!remoteUrl) {
-        debugLog2(`[GitLabProjectDetector] No git remote URL found`);
+        debugLog(`[GitLabProjectDetector] No git remote URL found`);
         return null;
       }
-      debugLog2(`[GitLabProjectDetector] Git remote URL: ${remoteUrl}`);
-      debugLog2(
+      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) {
-        debugLog2(
+        debugLog(
           `[GitLabProjectDetector] Could not parse project path from URL (remote doesn't match instance)`
         );
         return null;
       }
-      debugLog2(`[GitLabProjectDetector] Parsed project path: ${projectPath}`);
-      debugLog2(`[GitLabProjectDetector] Fetching project from GitLab API: ${projectPath}`);
+      debugLog(`[GitLabProjectDetector] Parsed project path: ${projectPath}`);
+      debugLog(`[GitLabProjectDetector] Fetching project from GitLab API: ${projectPath}`);
       const project = await this.getProjectByPath(projectPath);
-      debugLog2(`[GitLabProjectDetector] \u2713 Project fetched successfully:`, project);
+      debugLog(`[GitLabProjectDetector] \u2713 Project fetched successfully:`, project);
       this.cache.set(cacheKey, project);
       return project;
     } catch (error) {
       if (error instanceof GitLabError) {
-        debugLog2(`[GitLabProjectDetector] GitLab API error:`, error.message || error);
+        debugLog(`[GitLabProjectDetector] GitLab API error:`, error.message || error);
         return null;
       }
-      debugLog2(`[GitLabProjectDetector] Unexpected error:`, error);
+      debugLog(`[GitLabProjectDetector] Unexpected error:`, error);
       console.warn(`Failed to auto-detect GitLab project: ${error}`);
       return null;
     }