gitlab-ai-provider 6.13.0 → 6.14.0

package/dist/index.js

@@ -970,7 +970,12 @@ ${message.content}` : message.content;
       } else if (message.role === "assistant") {
         const content = [];
         for (const part of message.content) {
-          if (part.type === "text") {
+          if (part.type === "reasoning") {
+            const thinkingBlock = this.convertReasoningPart(part);
+            if (thinkingBlock) {
+              content.push(thinkingBlock);
+            }
+          } else if (part.type === "text") {
             content.push({ type: "text", text: part.text });
           } else if (part.type === "tool-call") {
             let toolInput = part.input;
@@ -1085,17 +1090,97 @@ ${message.content}` : message.content;
       raw: params?.raw
     };
   }
+  /**
+   * Translates the camelCase GitLab thinking config into the Anthropic Messages
+   * request fields. `adaptive` is required by effort-based models such as Claude
+   * Opus 4.8 and pairs `thinking: { type: 'adaptive' }` with a sibling
+   * `output_config: { effort }`; `enabled`/`disabled` map through directly.
+   */
+  buildThinkingParams(config) {
+    if (!config) return {};
+    if (config.type === "adaptive") {
+      return {
+        // Newer adaptive-only models (Claude Sonnet 5+, Opus 4.7+) default
+        // `thinking.display` to `'omitted'`, which returns *empty* thinking
+        // blocks — the model still reasons and effort still affects
+        // behavior/token usage, but no visible chain-of-thought text comes
+        // back. Older models already default to `'summarized'`, so it's
+        // safe to always request it explicitly rather than gating on model
+        // version.
+        thinking: { type: "adaptive", display: "summarized" },
+        output_config: { effort: config.effort }
+      };
+    }
+    if (config.type === "enabled") {
+      return { thinking: { type: "enabled", budget_tokens: config.budgetTokens } };
+    }
+    return { thinking: { type: "disabled" } };
+  }
+  /** Per-call thinking configuration takes precedence over the model-level default. */
+  resolveThinkingConfig(options) {
+    const gitlabOptions = options.providerOptions?.["gitlab"];
+    return gitlabOptions?.thinking ?? this.config.thinking;
+  }
+  validateThinkingConfig(config, maxTokens) {
+    if (config?.type === "enabled" && config.budgetTokens >= maxTokens) {
+      throw new GitLabError({
+        message: `Anthropic thinking budgetTokens (${config.budgetTokens}) must be less than maxTokens (${maxTokens}).`,
+        statusCode: 400
+      });
+    }
+  }
+  /**
+   * Rebuild an Anthropic thinking block from a prior-turn reasoning part.
+   * Anthropic requires thinking blocks to be replayed unmodified (with their
+   * signature) during tool-use loops; the signature / redacted payload are
+   * carried in the reasoning part's provider metadata under `gitlab`.
+   */
+  convertReasoningPart(part) {
+    const meta = part.providerOptions?.["gitlab"];
+    const redactedData = meta?.["redactedData"];
+    if (typeof redactedData === "string") {
+      return { type: "redacted_thinking", data: redactedData };
+    }
+    const signature = meta?.["signature"];
+    if (typeof signature !== "string") {
+      return void 0;
+    }
+    return { type: "thinking", thinking: part.text, signature };
+  }
+  isThinkingActive(config) {
+    return config?.type === "enabled" || config?.type === "adaptive";
+  }
+  /**
+   * Anthropic rejects `temperature` changes while thinking is active and requires
+   * `top_p` within [0.95, 1]; drop those params when thinking is engaged so the
+   * gateway does not 400. Undefined values are omitted either way.
+   */
+  buildSamplingParams(options, thinkingConfig) {
+    const params = {};
+    const thinkingActive = this.isThinkingActive(thinkingConfig);
+    if (options.temperature != null && !thinkingActive) {
+      params.temperature = options.temperature;
+    }
+    if (options.topP != null) {
+      if (!thinkingActive || options.topP >= 0.95 && options.topP <= 1) {
+        params.top_p = options.topP;
+      }
+    }
+    return params;
+  }
   async doGenerate(options) {
     return this.doGenerateWithRetry(options, false);
   }
   async doGenerateWithRetry(options, isRetry) {
-    const client = await this.getAnthropicClient(isRetry);
     const { system, messages } = this.convertPrompt(options.prompt);
     const toolsDisabled = options.toolChoice?.type === "none";
     const tools = toolsDisabled ? void 0 : this.convertTools(options.tools);
     const toolChoice = toolsDisabled ? void 0 : this.convertToolChoice(options.toolChoice);
     const anthropicModel = this.config.anthropicModel || "claude-sonnet-4-5-20250929";
     const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    const thinkingConfig = this.resolveThinkingConfig(options);
+    this.validateThinkingConfig(thinkingConfig, maxTokens);
+    const client = await this.getAnthropicClient(isRetry);
     const generateParams = {
       model: anthropicModel,
       max_tokens: maxTokens,
@@ -1103,15 +1188,27 @@ ${message.content}` : message.content;
       messages,
       tools,
       tool_choice: tools ? toolChoice : void 0,
-      temperature: options.temperature,
-      top_p: options.topP,
-      stop_sequences: options.stopSequences
+      ...this.buildSamplingParams(options, thinkingConfig),
+      stop_sequences: options.stopSequences,
+      ...this.buildThinkingParams(thinkingConfig)
     };
     try {
       const response = options.abortSignal ? await client.messages.create(generateParams, { signal: options.abortSignal }) : await client.messages.create(generateParams);
       const content = [];
       for (const block of response.content) {
-        if (block.type === "text") {
+        if (block.type === "thinking") {
+          content.push({
+            type: "reasoning",
+            text: block.thinking,
+            providerMetadata: { gitlab: { signature: block.signature } }
+          });
+        } else if (block.type === "redacted_thinking") {
+          content.push({
+            type: "reasoning",
+            text: "",
+            providerMetadata: { gitlab: { redactedData: block.data } }
+          });
+        } else if (block.type === "text") {
           content.push({
             type: "text",
             text: block.text
@@ -1165,13 +1262,15 @@ ${message.content}` : message.content;
     return this.doStreamWithRetry(options, false);
   }
   async doStreamWithRetry(options, isRetry) {
-    const client = await this.getAnthropicClient(isRetry);
     const { system, messages } = this.convertPrompt(options.prompt);
     const toolsDisabled = options.toolChoice?.type === "none";
     const tools = toolsDisabled ? void 0 : this.convertTools(options.tools);
     const toolChoice = toolsDisabled ? void 0 : this.convertToolChoice(options.toolChoice);
     const anthropicModel = this.config.anthropicModel || "claude-sonnet-4-5-20250929";
     const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    const thinkingConfig = this.resolveThinkingConfig(options);
+    this.validateThinkingConfig(thinkingConfig, maxTokens);
+    const client = await this.getAnthropicClient(isRetry);
     const requestBody = {
       model: anthropicModel,
       max_tokens: maxTokens,
@@ -1179,9 +1278,9 @@ ${message.content}` : message.content;
       messages,
       tools,
       tool_choice: tools ? toolChoice : void 0,
-      temperature: options.temperature,
-      top_p: options.topP,
+      ...this.buildSamplingParams(options, thinkingConfig),
       stop_sequences: options.stopSequences,
+      ...this.buildThinkingParams(thinkingConfig),
       stream: true
     };
     const self = this;
@@ -1280,6 +1379,24 @@ ${message.content}` : message.content;
                         type: "text-start",
                         id: textId
                       });
+                    } else if (event.content_block.type === "thinking") {
+                      const reasoningId = `reasoning-${event.index}`;
+                      contentBlocks[event.index] = { type: "reasoning", id: reasoningId };
+                      safeEnqueue({
+                        type: "reasoning-start",
+                        id: reasoningId
+                      });
+                    } else if (event.content_block.type === "redacted_thinking") {
+                      const reasoningId = `reasoning-${event.index}`;
+                      contentBlocks[event.index] = {
+                        type: "reasoning",
+                        id: reasoningId,
+                        redactedData: event.content_block.data
+                      };
+                      safeEnqueue({
+                        type: "reasoning-start",
+                        id: reasoningId
+                      });
                     } else if (event.content_block.type === "tool_use") {
                       contentBlocks[event.index] = {
                         type: "tool-call",
@@ -1302,6 +1419,14 @@ ${message.content}` : message.content;
                         id: block.id,
                         delta: event.delta.text
                       });
+                    } else if (event.delta.type === "thinking_delta" && block?.type === "reasoning") {
+                      safeEnqueue({
+                        type: "reasoning-delta",
+                        id: block.id,
+                        delta: event.delta.thinking
+                      });
+                    } else if (event.delta.type === "signature_delta" && block?.type === "reasoning") {
+                      block.signature = event.delta.signature;
                     } else if (event.delta.type === "input_json_delta" && block?.type === "tool-call") {
                       block.input += event.delta.partial_json;
                       safeEnqueue({
@@ -1319,6 +1444,13 @@ ${message.content}` : message.content;
                         type: "text-end",
                         id: block.id
                       });
+                    } else if (block?.type === "reasoning") {
+                      const gitlabMeta = block.redactedData != null ? { redactedData: block.redactedData } : block.signature != null ? { signature: block.signature } : void 0;
+                      safeEnqueue({
+                        type: "reasoning-end",
+                        id: block.id,
+                        ...gitlabMeta && { providerMetadata: { gitlab: gitlabMeta } }
+                      });
                     } else if (block?.type === "tool-call") {
                       safeEnqueue({
                         type: "tool-input-end",
@@ -1671,6 +1803,17 @@ var GitLabOpenAILanguageModel = class {
     }
     return parts.join(" | ");
   }
+  /**
+   * Per-call `providerOptions.gitlab.reasoningEffort` takes precedence over the
+   * model-level default.
+   */
+  resolveReasoningEffort(options) {
+    const gitlabOptions = options.providerOptions?.["gitlab"];
+    return gitlabOptions?.reasoningEffort ?? this.config.reasoningEffort;
+  }
+  asOpenAIReasoningEffort(effort) {
+    return effort;
+  }
   convertTools(tools) {
     if (!tools || tools.length === 0) {
       return void 0;
@@ -1945,6 +2088,7 @@ var GitLabOpenAILanguageModel = class {
     const toolChoice = toolsDisabled ? void 0 : this.convertToolChoice(options.toolChoice);
     const openaiModel = this.config.openaiModel || "gpt-4o";
     const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    const reasoningEffort = this.resolveReasoningEffort(options);
     const generateParams = {
       model: openaiModel,
       max_completion_tokens: maxTokens,
@@ -1953,7 +2097,10 @@ var GitLabOpenAILanguageModel = class {
       tool_choice: tools ? toolChoice : void 0,
       temperature: options.temperature,
       top_p: options.topP,
-      stop: options.stopSequences
+      stop: options.stopSequences,
+      ...reasoningEffort && {
+        reasoning_effort: this.asOpenAIReasoningEffort(reasoningEffort)
+      }
     };
     try {
       const response = options.abortSignal ? await client.chat.completions.create(generateParams, { signal: options.abortSignal }) : await client.chat.completions.create(generateParams);
@@ -2016,6 +2163,7 @@ var GitLabOpenAILanguageModel = class {
     const instructions = this.extractSystemInstructions(options.prompt);
     const openaiModel = this.config.openaiModel || "gpt-5-codex";
     const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    const reasoningEffort = this.resolveReasoningEffort(options);
     const generateParams = {
       model: openaiModel,
       input,
@@ -2024,7 +2172,18 @@ var GitLabOpenAILanguageModel = class {
       max_output_tokens: maxTokens,
       temperature: options.temperature,
       top_p: options.topP,
-      store: false
+      store: false,
+      ...reasoningEffort && {
+        // `summary: 'auto'` opts into visible reasoning summary text.
+        // Without it, the Responses API never returns summary content —
+        // the model still reasons and effort still affects behavior, but
+        // no chain-of-thought text comes back (mirrors the Anthropic
+        // `thinking.display` gap fixed in buildThinkingParams).
+        reasoning: {
+          effort: this.asOpenAIReasoningEffort(reasoningEffort),
+          summary: "auto"
+        }
+      }
     };
     try {
       const response = options.abortSignal ? await client.responses.create(generateParams, { signal: options.abortSignal }) : await client.responses.create(generateParams);
@@ -2045,6 +2204,12 @@ var GitLabOpenAILanguageModel = class {
             toolName: item.name,
             input: item.arguments
           });
+        } else if (item.type === "reasoning") {
+          for (const summary of item.summary || []) {
+            if (summary.type === "summary_text" && summary.text) {
+              content.push({ type: "reasoning", text: summary.text });
+            }
+          }
         }
       }
       const usage = this.createUsage({
@@ -2097,6 +2262,7 @@ var GitLabOpenAILanguageModel = class {
     const toolChoice = toolsDisabled ? void 0 : this.convertToolChoice(options.toolChoice);
     const openaiModel = this.config.openaiModel || "gpt-4o";
     const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    const reasoningEffort = this.resolveReasoningEffort(options);
     const requestBody = {
       model: openaiModel,
       max_completion_tokens: maxTokens,
@@ -2106,6 +2272,9 @@ var GitLabOpenAILanguageModel = class {
       temperature: options.temperature,
       top_p: options.topP,
       stop: options.stopSequences,
+      ...reasoningEffort && {
+        reasoning_effort: this.asOpenAIReasoningEffort(reasoningEffort)
+      },
       stream: true,
       stream_options: { include_usage: true }
     };
@@ -2313,6 +2482,7 @@ var GitLabOpenAILanguageModel = class {
     const instructions = this.extractSystemInstructions(options.prompt);
     const openaiModel = this.config.openaiModel || "gpt-5-codex";
     const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    const reasoningEffort = this.resolveReasoningEffort(options);
     const requestBody = {
       model: openaiModel,
       input,
@@ -2322,6 +2492,17 @@ var GitLabOpenAILanguageModel = class {
       temperature: options.temperature,
       top_p: options.topP,
       store: false,
+      ...reasoningEffort && {
+        // `summary: 'auto'` opts into visible reasoning summary text.
+        // Without it, the Responses API never returns summary content —
+        // the model still reasons and effort still affects behavior, but
+        // no chain-of-thought text comes back (mirrors the Anthropic
+        // `thinking.display` gap fixed in buildThinkingParams).
+        reasoning: {
+          effort: this.asOpenAIReasoningEffort(reasoningEffort),
+          summary: "auto"
+        }
+      },
       stream: true
     };
     const self = this;
@@ -2360,11 +2541,38 @@ var GitLabOpenAILanguageModel = class {
           }
         };
         const toolCalls = {};
+        const activeReasoning = /* @__PURE__ */ new Set();
+        const knownReasoning = /* @__PURE__ */ new Set();
+        const reasoningWithText = /* @__PURE__ */ new Set();
         let usage = self.createUsage();
         let finishReason = { unified: "other", raw: void 0 };
         let textStarted = false;
         let contentEmitted = false;
         const textId = "text-0";
+        const reasoningId = (outputIndex, summaryIndex) => `reasoning-${outputIndex}-${summaryIndex}`;
+        const startReasoning = (outputIndex, summaryIndex) => {
+          const id = reasoningId(outputIndex, summaryIndex);
+          if (!knownReasoning.has(id)) {
+            knownReasoning.add(id);
+            activeReasoning.add(id);
+            contentEmitted = true;
+            safeEnqueue({ type: "reasoning-start", id });
+          }
+          return id;
+        };
+        const emitReasoningDelta = (outputIndex, summaryIndex, delta) => {
+          const id = startReasoning(outputIndex, summaryIndex);
+          if (activeReasoning.has(id) && delta) {
+            reasoningWithText.add(id);
+            safeEnqueue({ type: "reasoning-delta", id, delta });
+          }
+        };
+        const endReasoning = (outputIndex, summaryIndex) => {
+          const id = reasoningId(outputIndex, summaryIndex);
+          if (activeReasoning.delete(id)) {
+            safeEnqueue({ type: "reasoning-end", id });
+          }
+        };
         try {
           const openaiStream = await client.responses.create(
             {
@@ -2397,6 +2605,30 @@ var GitLabOpenAILanguageModel = class {
                   toolName: event.item.name
                 });
               }
+            } else if (event.type === "response.reasoning_summary_part.added") {
+              startReasoning(event.output_index, event.summary_index);
+            } else if (event.type === "response.reasoning_summary_text.delta") {
+              emitReasoningDelta(event.output_index, event.summary_index, event.delta);
+            } else if (event.type === "response.reasoning_summary_text.done") {
+              const id = startReasoning(event.output_index, event.summary_index);
+              if (!reasoningWithText.has(id)) {
+                emitReasoningDelta(event.output_index, event.summary_index, event.text);
+              }
+              endReasoning(event.output_index, event.summary_index);
+            } else if (event.type === "response.reasoning_summary_part.done") {
+              const id = startReasoning(event.output_index, event.summary_index);
+              if (!reasoningWithText.has(id)) {
+                emitReasoningDelta(event.output_index, event.summary_index, event.part.text);
+              }
+              endReasoning(event.output_index, event.summary_index);
+            } else if (event.type === "response.output_item.done" && event.item.type === "reasoning") {
+              const prefix = `reasoning-${event.output_index}-`;
+              for (const id of [...activeReasoning]) {
+                if (id.startsWith(prefix)) {
+                  activeReasoning.delete(id);
+                  safeEnqueue({ type: "reasoning-end", id });
+                }
+              }
             } else if (event.type === "response.output_text.delta") {
               contentEmitted = true;
               if (!textStarted) {
@@ -2439,6 +2671,10 @@ var GitLabOpenAILanguageModel = class {
               }
             }
           }
+          for (const id of activeReasoning) {
+            safeEnqueue({ type: "reasoning-end", id });
+          }
+          activeReasoning.clear();
           if (textStarted) {
             safeEnqueue({ type: "text-end", id: textId });
           }
@@ -2531,7 +2767,7 @@ var import_node_async_hooks = require("async_hooks");
 var import_isomorphic_ws = __toESM(require("isomorphic-ws"));
 
 // src/version.ts
-var VERSION = true ? "6.12.2" : "0.0.0-dev";
+var VERSION = true ? "6.13.0" : "0.0.0-dev";
 
 // src/gitlab-workflow-client.ts
 var WS_CONNECT_TIMEOUT_MS = 3e4;
@@ -5378,12 +5614,14 @@ function createGitLab(options = {}) {
     if (mapping.provider === "openai") {
       return new GitLabOpenAILanguageModel(modelId, {
         ...baseConfig,
-        openaiModel: agenticOptions?.providerModel ?? mapping.model
+        openaiModel: agenticOptions?.providerModel ?? mapping.model,
+        reasoningEffort: agenticOptions?.reasoningEffort
       });
     }
     return new GitLabAnthropicLanguageModel(modelId, {
       ...baseConfig,
-      anthropicModel: agenticOptions?.providerModel ?? mapping.model
+      anthropicModel: agenticOptions?.providerModel ?? mapping.model,
+      thinking: agenticOptions?.thinking
     });
   };
   const createWorkflowChatModel = (modelId, workflowOptions) => {