gitlab-ai-provider 5.3.3 → 6.0.0

package/dist/index.mjs

@@ -171,7 +171,7 @@ var GitLabDirectAccessClient = class {
 
 // src/gitlab-anthropic-language-model.ts
 var GitLabAnthropicLanguageModel = class {
-  specificationVersion = "v2";
+  specificationVersion = "v3";
   modelId;
   supportedUrls = {};
   config;
@@ -330,10 +330,14 @@ ${message.content}` : message.content;
               resultContent = part.output.value;
             } else if (part.output.type === "json") {
               resultContent = JSON.stringify(part.output.value);
+            } else if (part.output.type === "content") {
+              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 if (part.output.type === "execution-denied") {
+              resultContent = part.output.reason ?? "Tool execution denied.";
             } else {
               resultContent = JSON.stringify(part.output);
             }
@@ -356,18 +360,41 @@ ${message.content}` : message.content;
    * 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";
-    }
+    const unified = (() => {
+      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 "other";
+      }
+    })();
+    return { unified, raw: stopReason ?? void 0 };
+  }
+  createUsage(params) {
+    const inputTotal = params?.inputTotal;
+    const outputTotal = params?.outputTotal;
+    const cacheRead = params?.cacheRead;
+    const cacheWrite = params?.cacheWrite;
+    return {
+      inputTokens: {
+        total: inputTotal,
+        noCache: inputTotal == null ? void 0 : Math.max(0, inputTotal - (cacheRead ?? 0) - (cacheWrite ?? 0)),
+        cacheRead,
+        cacheWrite
+      },
+      outputTokens: {
+        total: outputTotal,
+        text: outputTotal,
+        reasoning: params?.outputReasoning
+      },
+      raw: params?.raw
+    };
   }
   async doGenerate(options) {
     return this.doGenerateWithRetry(options, false);
@@ -407,11 +434,13 @@ ${message.content}` : message.content;
           });
         }
       }
-      const usage = {
-        inputTokens: response.usage.input_tokens,
-        outputTokens: response.usage.output_tokens,
-        totalTokens: response.usage.input_tokens + response.usage.output_tokens
-      };
+      const rawUsage = response.usage;
+      const usage = this.createUsage({
+        inputTotal: response.usage.input_tokens,
+        outputTotal: response.usage.output_tokens,
+        cacheRead: rawUsage.cache_read_input_tokens,
+        cacheWrite: rawUsage.cache_creation_input_tokens
+      });
       return {
         content,
         finishReason: this.convertFinishReason(response.stop_reason),
@@ -467,12 +496,8 @@ ${message.content}` : message.content;
     const stream = new ReadableStream({
       start: async (controller) => {
         const contentBlocks = {};
-        const usage = {
-          inputTokens: 0,
-          outputTokens: 0,
-          totalTokens: 0
-        };
-        let finishReason = "unknown";
+        let usage = self.createUsage();
+        let finishReason = { unified: "other", raw: void 0 };
         try {
           const anthropicStream = client.messages.stream(requestBody, {
             signal: options.abortSignal
@@ -487,7 +512,14 @@ ${message.content}` : message.content;
                 switch (event.type) {
                   case "message_start":
                     if (event.message.usage) {
-                      usage.inputTokens = event.message.usage.input_tokens;
+                      usage = self.createUsage({
+                        inputTotal: event.message.usage.input_tokens,
+                        outputTotal: usage.outputTokens.total,
+                        outputReasoning: usage.outputTokens.reasoning,
+                        cacheRead: usage.inputTokens.cacheRead,
+                        cacheWrite: usage.inputTokens.cacheWrite,
+                        raw: usage.raw
+                      });
                     }
                     controller.enqueue({
                       type: "response-metadata",
@@ -559,8 +591,14 @@ ${message.content}` : message.content;
                   }
                   case "message_delta":
                     if (event.usage) {
-                      usage.outputTokens = event.usage.output_tokens;
-                      usage.totalTokens = (usage.inputTokens || 0) + event.usage.output_tokens;
+                      usage = self.createUsage({
+                        inputTotal: usage.inputTokens.total,
+                        outputTotal: event.usage.output_tokens,
+                        outputReasoning: usage.outputTokens.reasoning,
+                        cacheRead: usage.inputTokens.cacheRead,
+                        cacheWrite: usage.inputTokens.cacheWrite,
+                        raw: usage.raw
+                      });
                     }
                     if (event.delta.stop_reason) {
                       finishReason = self.convertFinishReason(event.delta.stop_reason);
@@ -760,7 +798,7 @@ var MODEL_ID_TO_ANTHROPIC_MODEL = Object.fromEntries(
 
 // src/gitlab-openai-language-model.ts
 var GitLabOpenAILanguageModel = class {
-  specificationVersion = "v2";
+  specificationVersion = "v3";
   modelId;
   supportedUrls = {};
   config;
@@ -906,10 +944,14 @@ var GitLabOpenAILanguageModel = class {
               resultContent = part.output.value;
             } else if (part.output.type === "json") {
               resultContent = JSON.stringify(part.output.value);
+            } else if (part.output.type === "content") {
+              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 if (part.output.type === "execution-denied") {
+              resultContent = part.output.reason ?? "Tool execution denied.";
             } else {
               resultContent = JSON.stringify(part.output);
             }
@@ -925,18 +967,40 @@ var GitLabOpenAILanguageModel = class {
     return messages;
   }
   convertFinishReason(finishReason) {
-    switch (finishReason) {
-      case "stop":
-        return "stop";
-      case "length":
-        return "length";
-      case "tool_calls":
-        return "tool-calls";
-      case "content_filter":
-        return "content-filter";
-      default:
-        return "unknown";
-    }
+    const unified = (() => {
+      switch (finishReason) {
+        case "stop":
+          return "stop";
+        case "length":
+          return "length";
+        case "tool_calls":
+          return "tool-calls";
+        case "content_filter":
+          return "content-filter";
+        default:
+          return "other";
+      }
+    })();
+    return { unified, raw: finishReason ?? void 0 };
+  }
+  createUsage(params) {
+    const inputTotal = params?.inputTotal;
+    const outputTotal = params?.outputTotal;
+    const cacheRead = params?.cacheRead;
+    return {
+      inputTokens: {
+        total: inputTotal,
+        noCache: inputTotal == null ? void 0 : Math.max(0, inputTotal - (cacheRead ?? 0)),
+        cacheRead,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: outputTotal,
+        text: outputTotal,
+        reasoning: params?.outputReasoning
+      },
+      raw: params?.raw
+    };
   }
   /**
    * Convert tools to Responses API format
@@ -953,7 +1017,7 @@ var GitLabOpenAILanguageModel = class {
         name: tool.name,
         description: tool.description || "",
         parameters: schema,
-        strict: false
+        strict: tool.strict
       };
     });
   }
@@ -1004,10 +1068,14 @@ var GitLabOpenAILanguageModel = class {
               resultContent = part.output.value;
             } else if (part.output.type === "json") {
               resultContent = JSON.stringify(part.output.value);
+            } else if (part.output.type === "content") {
+              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 if (part.output.type === "execution-denied") {
+              resultContent = part.output.reason ?? "Tool execution denied.";
             } else {
               resultContent = JSON.stringify(part.output);
             }
@@ -1036,20 +1104,23 @@ var GitLabOpenAILanguageModel = class {
    */
   convertResponsesStatus(status, hasToolCalls = false) {
     if (hasToolCalls) {
-      return "tool-calls";
-    }
-    switch (status) {
-      case "completed":
-        return "stop";
-      case "incomplete":
-        return "length";
-      case "cancelled":
-        return "stop";
-      case "failed":
-        return "error";
-      default:
-        return "unknown";
-    }
+      return { unified: "tool-calls", raw: status };
+    }
+    const unified = (() => {
+      switch (status) {
+        case "completed":
+          return "stop";
+        case "incomplete":
+          return "length";
+        case "cancelled":
+          return "stop";
+        case "failed":
+          return "error";
+        default:
+          return "other";
+      }
+    })();
+    return { unified, raw: status };
   }
   async doGenerate(options) {
     if (this.useResponsesApi) {
@@ -1092,11 +1163,12 @@ var GitLabOpenAILanguageModel = class {
           }
         }
       }
-      const usage = {
-        inputTokens: response.usage?.prompt_tokens || 0,
-        outputTokens: response.usage?.completion_tokens || 0,
-        totalTokens: response.usage?.total_tokens || 0
-      };
+      const usage = this.createUsage({
+        inputTotal: response.usage?.prompt_tokens,
+        outputTotal: response.usage?.completion_tokens,
+        cacheRead: response.usage?.prompt_tokens_details?.cached_tokens,
+        raw: { total_tokens: response.usage?.total_tokens }
+      });
       return {
         content,
         finishReason: this.convertFinishReason(choice?.finish_reason),
@@ -1163,11 +1235,13 @@ var GitLabOpenAILanguageModel = class {
           });
         }
       }
-      const usage = {
-        inputTokens: response.usage?.input_tokens || 0,
-        outputTokens: response.usage?.output_tokens || 0,
-        totalTokens: response.usage?.total_tokens || 0
-      };
+      const usage = this.createUsage({
+        inputTotal: response.usage?.input_tokens,
+        outputTotal: response.usage?.output_tokens,
+        outputReasoning: response.usage?.output_tokens_details?.reasoning_tokens,
+        cacheRead: response.usage?.input_tokens_details?.cached_tokens,
+        raw: { total_tokens: response.usage?.total_tokens }
+      });
       return {
         content,
         finishReason: this.convertResponsesStatus(response.status, hasToolCalls),
@@ -1226,12 +1300,8 @@ var GitLabOpenAILanguageModel = class {
     const stream = new ReadableStream({
       start: async (controller) => {
         const toolCalls = {};
-        const usage = {
-          inputTokens: 0,
-          outputTokens: 0,
-          totalTokens: 0
-        };
-        let finishReason = "unknown";
+        let usage = self.createUsage();
+        let finishReason = { unified: "other", raw: void 0 };
         let textStarted = false;
         const textId = "text-0";
         try {
@@ -1289,9 +1359,12 @@ var GitLabOpenAILanguageModel = class {
               finishReason = self.convertFinishReason(choice.finish_reason);
             }
             if (chunk.usage) {
-              usage.inputTokens = chunk.usage.prompt_tokens || 0;
-              usage.outputTokens = chunk.usage.completion_tokens || 0;
-              usage.totalTokens = chunk.usage.total_tokens || 0;
+              usage = self.createUsage({
+                inputTotal: chunk.usage.prompt_tokens,
+                outputTotal: chunk.usage.completion_tokens,
+                cacheRead: chunk.usage.prompt_tokens_details?.cached_tokens,
+                raw: { total_tokens: chunk.usage.total_tokens }
+              });
             }
           }
           if (textStarted) {
@@ -1371,12 +1444,8 @@ var GitLabOpenAILanguageModel = class {
     const stream = new ReadableStream({
       start: async (controller) => {
         const toolCalls = {};
-        const usage = {
-          inputTokens: 0,
-          outputTokens: 0,
-          totalTokens: 0
-        };
-        let finishReason = "unknown";
+        let usage = self.createUsage();
+        let finishReason = { unified: "other", raw: void 0 };
         let textStarted = false;
         const textId = "text-0";
         try {
@@ -1438,9 +1507,13 @@ var GitLabOpenAILanguageModel = class {
               const hasToolCalls2 = Object.keys(toolCalls).length > 0;
               finishReason = self.convertResponsesStatus(event.response.status, hasToolCalls2);
               if (event.response.usage) {
-                usage.inputTokens = event.response.usage.input_tokens || 0;
-                usage.outputTokens = event.response.usage.output_tokens || 0;
-                usage.totalTokens = event.response.usage.total_tokens || 0;
+                usage = self.createUsage({
+                  inputTotal: event.response.usage.input_tokens,
+                  outputTotal: event.response.usage.output_tokens,
+                  outputReasoning: event.response.usage.output_tokens_details?.reasoning_tokens,
+                  cacheRead: event.response.usage.input_tokens_details?.cached_tokens,
+                  raw: { total_tokens: event.response.usage.total_tokens }
+                });
               }
             }
           }
@@ -1448,8 +1521,8 @@ var GitLabOpenAILanguageModel = class {
             controller.enqueue({ type: "text-end", id: textId });
           }
           const hasToolCalls = Object.keys(toolCalls).length > 0;
-          if (hasToolCalls && finishReason === "stop") {
-            finishReason = "tool-calls";
+          if (hasToolCalls && finishReason.unified === "stop") {
+            finishReason = { unified: "tool-calls", raw: finishReason.raw };
           }
           for (const tc of Object.values(toolCalls)) {
             controller.enqueue({ type: "tool-input-end", id: tc.callId });
@@ -1509,7 +1582,7 @@ var GitLabOpenAILanguageModel = class {
 import WebSocket from "isomorphic-ws";
 
 // src/version.ts
-var VERSION = true ? "5.3.2" : "0.0.0-dev";
+var VERSION = true ? "5.3.3" : "0.0.0-dev";
 
 // src/gitlab-workflow-types.ts
 var WorkflowType = /* @__PURE__ */ ((WorkflowType2) => {
@@ -2873,7 +2946,7 @@ function minimalSchema(schemaStr) {
   }
 }
 var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
-  specificationVersion = "v2";
+  specificationVersion = "v3";
   modelId;
   supportedUrls = {};
   config;
@@ -3174,16 +3247,34 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
   get workflowId() {
     return this.currentWorkflowId;
   }
+  createUsage(params) {
+    return {
+      inputTokens: {
+        total: params?.inputTotal,
+        noCache: params?.inputTotal,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: params?.outputTotal,
+        text: params?.outputTotal,
+        reasoning: void 0
+      }
+    };
+  }
+  createFinishReason(unified, raw) {
+    return { unified, raw };
+  }
   // ---------------------------------------------------------------------------
-  // LanguageModelV2 — doGenerate (non-streaming)
+  // LanguageModelV3 — doGenerate (non-streaming)
   // ---------------------------------------------------------------------------
   async doGenerate(options) {
     const { stream } = await this.doStream(options);
     const reader = stream.getReader();
     const textParts = [];
     const toolCalls = [];
-    let finishReason = "unknown";
-    const usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    let finishReason = { unified: "other", raw: void 0 };
+    let usage = this.createUsage();
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -3203,9 +3294,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
           case "finish":
             finishReason = value.finishReason;
             if (value.usage) {
-              usage.inputTokens = value.usage.inputTokens ?? 0;
-              usage.outputTokens = value.usage.outputTokens ?? 0;
-              usage.totalTokens = value.usage.totalTokens ?? 0;
+              usage = value.usage;
             }
             break;
           case "error":
@@ -3224,7 +3313,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
     return { content, finishReason, usage, warnings: [] };
   }
   // ---------------------------------------------------------------------------
-  // LanguageModelV2 — doStream (streaming)
+  // LanguageModelV3 — doStream (streaming)
   // ---------------------------------------------------------------------------
   async doStream(options) {
     const goal = this.extractGoalFromPrompt(options.prompt);
@@ -3490,8 +3579,8 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
           const outputTokens = Math.ceil(ss.streamedOutputChars / 4);
           controller.enqueue({
             type: "finish",
-            finishReason: "stop",
-            usage: { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens }
+            finishReason: this.createFinishReason("stop", "completed"),
+            usage: this.createUsage({ inputTotal: inputTokens, outputTotal: outputTokens })
           });
           ss.streamClosed = true;
           controller.close();
@@ -3548,8 +3637,8 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
             const outTok = Math.ceil(ss.streamedOutputChars / 4);
             controller.enqueue({
               type: "finish",
-              finishReason: "stop",
-              usage: { inputTokens: inTok, outputTokens: outTok, totalTokens: inTok + outTok }
+              finishReason: this.createFinishReason("stop", "closed"),
+              usage: this.createUsage({ inputTotal: inTok, outputTotal: outTok })
             });
             ss.streamClosed = true;
             controller.close();
@@ -3666,8 +3755,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
             toolCallId: requestID,
             toolName,
             result: errorText,
-            isError: true,
-            providerExecuted: true
+            isError: true
           });
         } else {
           safeEnqueue({
@@ -3679,8 +3767,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
               title: toolTitle,
               metadata: toolMetadata
             },
-            isError: false,
-            providerExecuted: true
+            isError: false
           });
         }
       } else {
@@ -3691,8 +3778,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
           toolCallId: requestID,
           toolName,
           result: errorMsg,
-          isError: true,
-          providerExecuted: true
+          isError: true
         });
       }
     } catch (error) {
@@ -3704,8 +3790,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         toolCallId: requestID,
         toolName,
         result: errorMsg,
-        isError: true,
-        providerExecuted: true
+        isError: true
       });
     } finally {
       ss.pendingToolCount--;
@@ -4304,13 +4389,13 @@ function createGitLab(options = {}) {
     return createAgenticChatModel(modelId);
   };
   const provider = Object.assign((modelId) => createDefaultModel(modelId), {
-    specificationVersion: "v2",
+    specificationVersion: "v3",
     languageModel: createDefaultModel,
     chat: createDefaultModel,
     agenticChat: createAgenticChatModel,
     workflowChat: createWorkflowChatModel
   });
-  provider.textEmbeddingModel = (modelId) => {
+  provider.embeddingModel = (modelId) => {
     throw new GitLabError({
       message: `GitLab provider does not support text embedding models. Model ID: ${modelId}`
     });