gitlab-ai-provider 5.3.3 → 6.1.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 ? "6.0.0" : "0.0.0-dev";
 
 // src/gitlab-workflow-types.ts
 var WorkflowType = /* @__PURE__ */ ((WorkflowType2) => {
@@ -1735,7 +1808,9 @@ var GitLabWorkflowClient = class {
         });
       } else if (checkpoint.status === "STOPPED" || checkpoint.status === "CANCELLED") {
         this.emit({ type: "completed" });
-      } else if (checkpoint.status === "TOOL_CALL_APPROVAL_REQUIRED" || checkpoint.status === "PLAN_APPROVAL_REQUIRED") {
+      } else if (checkpoint.status === "TOOL_CALL_APPROVAL_REQUIRED") {
+        this.emit({ type: "approval-required", tools: this.extractApprovalTools(checkpoint) });
+      } else if (checkpoint.status === "PLAN_APPROVAL_REQUIRED") {
         this.emit({ type: "completed" });
       }
       return;
@@ -1774,6 +1849,18 @@ var GitLabWorkflowClient = class {
       }
     }
   }
+  extractApprovalTools(checkpoint) {
+    if (!checkpoint.checkpoint) return [];
+    let parsed;
+    try {
+      parsed = JSON.parse(checkpoint.checkpoint);
+    } catch {
+      return [];
+    }
+    return (parsed.channel_values?.ui_chat_log ?? []).filter(
+      (e) => e.message_type === "request" && e.tool_info !== null
+    ).map((e) => ({ name: e.tool_info.name, args: JSON.stringify(e.tool_info.args) }));
+  }
   send(event) {
     if (this.socket?.readyState === WebSocket.OPEN) {
       const json = JSON.stringify(event);
@@ -2873,7 +2960,7 @@ function minimalSchema(schemaStr) {
   }
 }
 var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
-  specificationVersion = "v2";
+  specificationVersion = "v3";
   modelId;
   supportedUrls = {};
   config;
@@ -2945,6 +3032,23 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
    * the AI SDK only surfaces usage via finish-step at stream end.
    */
   onUsageUpdate = null;
+  /**
+   * Tool names pre-approved for the current session.
+   * Set by the host (e.g., opencode) and merged into preapproved_tools on each StartRequest.
+   * Updated when the user chooses "always" in the approval prompt.
+   */
+  sessionPreapprovedTools = [];
+  /**
+   * Set the approval handler callback.
+   * Called when DWS requires tool call approval. Host (e.g., opencode) wires this
+   * to its permission system each stream call, similar to toolExecutor.
+   */
+  set approvalHandler(handler) {
+    this.workflowOptions.approvalHandler = handler ?? void 0;
+  }
+  get approvalHandler() {
+    return this.workflowOptions.approvalHandler ?? null;
+  }
   /**
    * Optional callback invoked when multiple workflow models are available
    * and the user should pick one. Set per-stream by the host (e.g., OpenCode)
@@ -3174,16 +3278,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 +3325,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,13 +3344,16 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
     return { content, finishReason, usage, warnings: [] };
   }
   // ---------------------------------------------------------------------------
-  // LanguageModelV2 — doStream (streaming)
+  // LanguageModelV3 — doStream (streaming)
   // ---------------------------------------------------------------------------
   async doStream(options) {
     const goal = this.extractGoalFromPrompt(options.prompt);
     const modelRef = await this.resolveModelRef();
     const mcpTools = this.extractMcpTools(options);
-    const preapprovedTools = this.workflowOptions.preapprovedTools ?? mcpTools.map((t) => t.name);
+    const preapprovedTools = [
+      ...this.workflowOptions.preapprovedTools ?? mcpTools.map((t) => t.name),
+      ...this.sessionPreapprovedTools
+    ];
     const additionalContext = this.buildAdditionalContext(options.prompt);
     const toolExecutor = this.toolExecutor ?? null;
     const availableToolNames = new Set(options.tools?.map((t) => t.name) ?? []);
@@ -3246,7 +3369,8 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
       workflowId = await this.tokenClient.createWorkflow(goal, {
         projectId,
         namespaceId: this.workflowOptions.namespaceId,
-        workflowDefinition: this.workflowOptions.workflowDefinition
+        workflowDefinition: this.workflowOptions.workflowDefinition,
+        agentPrivileges: this.workflowOptions.agentPrivileges
       });
       this.currentWorkflowId = workflowId;
     }
@@ -3258,11 +3382,13 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
       streamedInputChars: 0,
       streamedOutputChars: 0,
       pendingToolCount: 0,
+      approvalPending: false,
       deferredClose: null,
       activeTextBlockId: null,
       agentMessageEmitted: new Map(this.persistedAgentEmitted),
       currentAgentMessageId: "",
-      activeClient: wsClient
+      activeClient: wsClient,
+      processedRequestIDs: /* @__PURE__ */ new Set()
     };
     for (const msg of options.prompt) {
       if (msg.role === "system") {
@@ -3275,6 +3401,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         }
       }
     }
+    let startReq;
     const stream = new ReadableStream({
       start: async (controller) => {
         try {
@@ -3295,7 +3422,8 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
                 wsClient,
                 toolExecutor,
                 () => `text-${textBlockCounter++}`,
-                availableToolNames
+                availableToolNames,
+                startReq
               );
             }
           );
@@ -3317,7 +3445,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
           const trimmedPreapproved = preapprovedTools.filter(
             (name) => trimmed.mcpTools.some((t) => t.name === name)
           );
-          const startReq = {
+          startReq = {
             workflowID: workflowId,
             clientVersion: CLIENT_VERSION,
             workflowDefinition: workflowDef,
@@ -3382,7 +3510,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
   // ---------------------------------------------------------------------------
   // Event handling
   // ---------------------------------------------------------------------------
-  handleWorkflowEvent(ss, event, controller, wsClient, toolExecutor, nextTextId, availableToolNames) {
+  handleWorkflowEvent(ss, event, controller, wsClient, toolExecutor, nextTextId, availableToolNames, startReq) {
     if (ss.streamClosed) {
       return;
     }
@@ -3393,6 +3521,8 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
       }
       case "tool-request": {
         const { requestID, data } = event;
+        if (ss.processedRequestIDs.has(requestID)) break;
+        ss.processedRequestIDs.add(requestID);
         let parsedArgs;
         try {
           JSON.parse(data.args);
@@ -3439,6 +3569,8 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         break;
       }
       case "builtin-tool-request": {
+        if (ss.processedRequestIDs.has(event.requestID)) break;
+        ss.processedRequestIDs.add(event.requestID);
         const mapped = mapBuiltinTool(event.toolName, event.data, availableToolNames);
         const mappedArgs = JSON.stringify(mapped.args);
         if (ss.activeTextBlockId) {
@@ -3479,6 +3611,26 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         });
         break;
       }
+      case "approval-required": {
+        ss.approvalPending = true;
+        this.approveAndResume(
+          ss,
+          event.tools,
+          startReq,
+          controller,
+          toolExecutor,
+          nextTextId,
+          availableToolNames
+        ).catch(() => {
+          ss.approvalPending = false;
+          if (ss.deferredClose) {
+            const close = ss.deferredClose;
+            ss.deferredClose = null;
+            close();
+          }
+        });
+        break;
+      }
       case "completed": {
         if (ss.activeTextBlockId) {
           controller.enqueue({ type: "text-end", id: ss.activeTextBlockId });
@@ -3490,14 +3642,14 @@ 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();
           this.cleanupClient(ss);
         };
-        if (ss.pendingToolCount > 0) {
+        if (ss.pendingToolCount > 0 || ss.approvalPending) {
           ss.deferredClose = doCompleteClose;
         } else {
           ss.deferredClose = null;
@@ -3548,15 +3700,15 @@ 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();
             this.cleanupClient(ss);
           }
         };
-        if (ss.pendingToolCount > 0) {
+        if (ss.pendingToolCount > 0 || ss.approvalPending) {
           ss.deferredClose = doClose;
         } else {
           ss.deferredClose = null;
@@ -3666,8 +3818,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
             toolCallId: requestID,
             toolName,
             result: errorText,
-            isError: true,
-            providerExecuted: true
+            isError: true
           });
         } else {
           safeEnqueue({
@@ -3679,8 +3830,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
               title: toolTitle,
               metadata: toolMetadata
             },
-            isError: false,
-            providerExecuted: true
+            isError: false
           });
         }
       } else {
@@ -3691,8 +3841,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
           toolCallId: requestID,
           toolName,
           result: errorMsg,
-          isError: true,
-          providerExecuted: true
+          isError: true
         });
       }
     } catch (error) {
@@ -3704,8 +3853,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         toolCallId: requestID,
         toolName,
         result: errorMsg,
-        isError: true,
-        providerExecuted: true
+        isError: true
       });
     } finally {
       ss.pendingToolCount--;
@@ -3736,6 +3884,60 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
       this.persistedAgentEmitted.clear();
     }
   }
+  async approveAndResume(ss, tools, startReq, controller, toolExecutor, nextTextId, availableToolNames) {
+    const handler = this.workflowOptions.approvalHandler;
+    if (!handler || !startReq) {
+      ss.approvalPending = false;
+      if (ss.deferredClose) {
+        const close = ss.deferredClose;
+        ss.deferredClose = null;
+        close();
+      }
+      return;
+    }
+    let decision;
+    try {
+      decision = await handler(tools);
+    } catch (err) {
+      ss.approvalPending = false;
+      if (!ss.streamClosed) controller.error(err);
+      return;
+    }
+    ss.approvalPending = false;
+    this.cleanupClient(ss, false);
+    const approval = decision.approved ? { approval: { tool_name: tools[0]?.name, tool_args_json: tools[0]?.args } } : { rejection: { message: decision.message ?? "User rejected" } };
+    const newStartReq = { ...startReq, approval };
+    const newClient = new GitLabWorkflowClient();
+    this.activeClients.add(newClient);
+    ss.activeClient = newClient;
+    const modelRef = await this.resolveModelRef();
+    try {
+      await newClient.connect(
+        {
+          instanceUrl: this.config.instanceUrl,
+          modelRef,
+          headers: this.config.getHeaders(),
+          projectId: this.workflowOptions.projectId,
+          namespaceId: this.workflowOptions.namespaceId,
+          rootNamespaceId: this.workflowOptions.rootNamespaceId
+        },
+        (event) => this.handleWorkflowEvent(
+          ss,
+          event,
+          controller,
+          newClient,
+          toolExecutor,
+          nextTextId,
+          availableToolNames,
+          newStartReq
+        )
+      );
+      newClient.sendStartRequest(newStartReq);
+    } catch (err) {
+      this.cleanupClient(ss, true);
+      if (!ss.streamClosed) controller.error(err);
+    }
+  }
   // ---------------------------------------------------------------------------
   // Workflow metadata
   // ---------------------------------------------------------------------------
@@ -4304,13 +4506,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}`
     });