gitlab-ai-provider 6.4.0 → 6.4.1

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## <small>6.4.1 (2026-04-06)</small>
+
+- fix(workflow): surface server-side MCP tool calls as structured AI SDK events ([fcae357](https://gitlab.com/vglafirov/gitlab-ai-provider/commit/fcae357))
+
 ## 6.4.0 (2026-04-02)
 
 - chore: regenerate dist ([c6833c4](https://gitlab.com/vglafirov/gitlab-ai-provider/commit/c6833c4))

package/README.md

@@ -334,6 +334,37 @@ The workflow service automatically maps DWS built-in tools to consumer tool name
 | `mkdir`           | `bash`        | Create directory              |
 | `runHTTPRequest`  | `bash`        | Execute HTTP request          |
 
+**Server-Side Tool Visibility:**
+
+When DWS executes tools on the server (e.g., MCP tools like Linear or Context7 that are configured in the agent's catalog), the provider automatically surfaces these as structured AI SDK stream events (`tool-input-start`, `tool-call`, `tool-result`) with `providerExecuted: true` and `dynamic: true`. This allows host applications to display server-side tool calls in their UI alongside locally-executed tools.
+
+Server-side tool events are deduplicated across turns — the provider tracks emitted checkpoint tool entries in the persistent session state so that cumulative DWS checkpoints don't re-emit tools from previous turns. Tools that were already handled via `tool-request` (client-executed tools) are also excluded from checkpoint emission to avoid duplicates.
+
+Since server-side MCP tools are not registered in the host's tool registry, the `dynamic: true` flag ensures the AI SDK's `parseToolCall` bypasses tool registry validation via the `parseProviderExecutedDynamicToolCall` path.
+
+**Tool Call Approval:**
+
+The workflow model supports an approval flow for tool execution. When DWS requires approval before executing a tool, it sends a `TOOL_CALL_APPROVAL_REQUIRED` checkpoint. The provider exposes this via the `approvalHandler` callback:
+
+```typescript
+const model = gitlab.workflowChat('duo-workflow');
+
+// Set approval handler — called when DWS requests tool execution approval
+model.approvalHandler = async (tools) => {
+  // tools: Array<{ name: string, args: string }>
+  console.log(
+    'Approval requested for:',
+    tools.map((t) => t.name)
+  );
+  return { approved: true }; // or { approved: false }
+};
+
+// Pre-approve specific tools to skip approval prompts
+model.sessionPreapprovedTools = ['read', 'glob', 'grep'];
+```
+
+Approved tools are tracked per-session. When the user approves a tool via "allow always", the provider automatically pre-approves it on subsequent DWS reconnections within the same session.
+
 **Workflow Options:**
 
 ```typescript
@@ -499,6 +530,8 @@ Provides server-side agentic execution through GitLab Duo Workflow Service.
 - Dynamic model discovery via GraphQL (`aiChatAvailableModels`)
 - Automatic model selection (pinned → user-selected → default)
 - Built-in tool mapping and MCP tool support
+- Server-side tool visibility — DWS-executed MCP tools are surfaced as structured AI SDK events
+- Tool call approval flow with per-session pre-approval tracking
 - Per-stream state isolation for concurrent requests
 - Dual heartbeat (WebSocket ping + JSON heartbeat)
 

package/dist/index.js

@@ -1653,7 +1653,7 @@ var GitLabOpenAILanguageModel = class {
 var import_isomorphic_ws = __toESM(require("isomorphic-ws"));
 
 // src/version.ts
-var VERSION = true ? "6.3.0" : "0.0.0-dev";
+var VERSION = true ? "6.4.0" : "0.0.0-dev";
 
 // src/gitlab-workflow-types.ts
 var WorkflowType = /* @__PURE__ */ ((WorkflowType2) => {
@@ -3490,7 +3490,8 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         this.sessionWorkflows.set(sessionKey, {
           workflowId,
           workflowDefinition: effectiveDefinition,
-          agentEmitted: /* @__PURE__ */ new Map()
+          agentEmitted: /* @__PURE__ */ new Map(),
+          toolEntries: /* @__PURE__ */ new Set()
         });
         sess = this.sessionWorkflows.get(sessionKey);
       }
@@ -3510,6 +3511,8 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
       currentAgentMessageId: "",
       activeClient: wsClient,
       processedRequestIDs: /* @__PURE__ */ new Set(),
+      emittedToolEntries: new Set(sess?.toolEntries),
+      emittedToolKeys: /* @__PURE__ */ new Set(),
       sessionKey
     };
     for (const msg of options.prompt) {
@@ -3659,6 +3662,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         const { requestID, data } = event;
         if (ss.processedRequestIDs.has(requestID)) break;
         ss.processedRequestIDs.add(requestID);
+        ss.emittedToolKeys.add(data.name);
         let parsedArgs;
         try {
           JSON.parse(data.args);
@@ -3708,6 +3712,7 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
         if (ss.processedRequestIDs.has(event.requestID)) break;
         ss.processedRequestIDs.add(event.requestID);
         const mapped = mapBuiltinTool(event.toolName, event.data, availableToolNames);
+        ss.emittedToolKeys.add(mapped.toolName);
         const mappedArgs = JSON.stringify(mapped.args);
         if (ss.activeTextBlockId) {
           controller.enqueue({ type: "text-end", id: ss.activeTextBlockId });
@@ -3889,6 +3894,51 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
     }
     for (let i = 0; i < chatLog.length; i++) {
       const entry = chatLog[i];
+      if (entry.message_type === "tool" && entry.tool_info) {
+        const toolId = entry.message_id || entry.correlation_id || `tool-${i}`;
+        if (ss.emittedToolEntries.has(toolId)) continue;
+        const name = entry.tool_info.name;
+        const args = JSON.stringify(entry.tool_info.args ?? {});
+        if (ss.emittedToolKeys.has(name)) {
+          ss.emittedToolEntries.add(toolId);
+          const sess2 = this.sessionWorkflows.get(ss.sessionKey);
+          if (sess2) sess2.toolEntries.add(toolId);
+          continue;
+        }
+        if (ss.activeTextBlockId) {
+          controller.enqueue({ type: "text-end", id: ss.activeTextBlockId });
+          ss.activeTextBlockId = null;
+        }
+        controller.enqueue({
+          type: "tool-input-start",
+          id: toolId,
+          toolName: name,
+          providerExecuted: true
+        });
+        controller.enqueue({ type: "tool-input-delta", id: toolId, delta: args });
+        controller.enqueue({ type: "tool-input-end", id: toolId });
+        controller.enqueue({
+          type: "tool-call",
+          toolCallId: toolId,
+          toolName: name,
+          input: args,
+          providerExecuted: true,
+          dynamic: true
+        });
+        const response = entry.tool_info.tool_response;
+        const output = typeof response === "string" ? response : response ? response.content : entry.content || "";
+        controller.enqueue({
+          type: "tool-result",
+          toolCallId: toolId,
+          toolName: name,
+          result: { output, title: name, metadata: {} },
+          isError: false
+        });
+        ss.emittedToolEntries.add(toolId);
+        const sess = this.sessionWorkflows.get(ss.sessionKey);
+        if (sess) sess.toolEntries.add(toolId);
+        continue;
+      }
       if (entry.message_type !== "agent") continue;
       const content = entry.content || "";
       const msgId = entry.message_id || `idx-${i}`;