@gitlab/gitlab-ai-provider 3.1.2 → 3.2.0

package/dist/index.js

@@ -32,22 +32,30 @@ __export(index_exports, {
   BUNDLED_CLIENT_ID: () => BUNDLED_CLIENT_ID,
   DEFAULT_AI_GATEWAY_URL: () => DEFAULT_AI_GATEWAY_URL,
   GITLAB_COM_URL: () => GITLAB_COM_URL,
-  GitLabAgenticLanguageModel: () => GitLabAgenticLanguageModel,
+  GitLabAnthropicLanguageModel: () => GitLabAnthropicLanguageModel,
   GitLabDirectAccessClient: () => GitLabDirectAccessClient,
   GitLabError: () => GitLabError,
   GitLabOAuthManager: () => GitLabOAuthManager,
+  GitLabOpenAILanguageModel: () => GitLabOpenAILanguageModel,
   GitLabProjectCache: () => GitLabProjectCache,
   GitLabProjectDetector: () => GitLabProjectDetector,
   MODEL_ID_TO_ANTHROPIC_MODEL: () => MODEL_ID_TO_ANTHROPIC_MODEL,
+  MODEL_MAPPINGS: () => MODEL_MAPPINGS,
   OAUTH_SCOPES: () => OAUTH_SCOPES,
   TOKEN_EXPIRY_SKEW_MS: () => TOKEN_EXPIRY_SKEW_MS,
   createGitLab: () => createGitLab,
   getAnthropicModelForModelId: () => getAnthropicModelForModelId,
-  gitlab: () => gitlab
+  getModelMapping: () => getModelMapping,
+  getOpenAIApiType: () => getOpenAIApiType,
+  getOpenAIModelForModelId: () => getOpenAIModelForModelId,
+  getProviderForModelId: () => getProviderForModelId,
+  getValidModelsForProvider: () => getValidModelsForProvider,
+  gitlab: () => gitlab,
+  isResponsesApiModel: () => isResponsesApiModel
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/gitlab-agentic-language-model.ts
+// src/gitlab-anthropic-language-model.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 
 // src/gitlab-direct-access.ts
@@ -182,6 +190,15 @@ var GitLabDirectAccessClient = class {
     const baseUrl = this.aiGatewayUrl.replace(/\/$/, "");
     return `${baseUrl}/ai/v1/proxy/anthropic/`;
   }
+  /**
+   * Get the OpenAI proxy base URL
+   * Note: The OpenAI SDK expects a base URL like https://api.openai.com/v1
+   * and appends paths like /chat/completions. So we need /v1 at the end.
+   */
+  getOpenAIProxyUrl() {
+    const baseUrl = this.aiGatewayUrl.replace(/\/$/, "");
+    return `${baseUrl}/ai/v1/proxy/openai/v1`;
+  }
   /**
    * Invalidate the cached token
    */
@@ -191,10 +208,8 @@ var GitLabDirectAccessClient = class {
   }
 };
 
-// src/gitlab-agentic-language-model.ts
-var debugLog = (..._args) => {
-};
-var GitLabAgenticLanguageModel = class {
+// src/gitlab-anthropic-language-model.ts
+var GitLabAnthropicLanguageModel = class {
   specificationVersion = "v2";
   modelId;
   supportedUrls = {};
@@ -222,14 +237,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 import_sdk.default({
       apiKey: null,
       authToken: tokenData.token,
@@ -468,114 +476,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: "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: "tool-call",
-                      toolCallId: block.id,
-                      toolName: block.name,
-                      input: JSON.stringify(block.input)
+                      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({
@@ -613,6 +662,740 @@ var GitLabAgenticLanguageModel = class {
   }
 };
 
+// src/gitlab-openai-language-model.ts
+var import_openai = __toESM(require("openai"));
+
+// src/model-mappings.ts
+var MODEL_MAPPINGS = {
+  // Anthropic models
+  "duo-chat-opus-4-5": { provider: "anthropic", model: "claude-opus-4-5-20251101" },
+  "duo-chat-sonnet-4-5": { provider: "anthropic", model: "claude-sonnet-4-5-20250929" },
+  "duo-chat-haiku-4-5": { provider: "anthropic", model: "claude-haiku-4-5-20251001" },
+  // OpenAI models - Chat Completions API
+  "duo-chat-gpt-5-1": { provider: "openai", model: "gpt-5.1-2025-11-13", openaiApiType: "chat" },
+  "duo-chat-gpt-5-mini": {
+    provider: "openai",
+    model: "gpt-5-mini-2025-08-07",
+    openaiApiType: "chat"
+  },
+  // OpenAI models - Responses API (Codex models)
+  "duo-chat-gpt-5-codex": { provider: "openai", model: "gpt-5-codex", openaiApiType: "responses" },
+  "duo-chat-gpt-5-2-codex": {
+    provider: "openai",
+    model: "gpt-5.2-codex",
+    openaiApiType: "responses"
+  }
+};
+function getModelMapping(modelId) {
+  return MODEL_MAPPINGS[modelId];
+}
+function getProviderForModelId(modelId) {
+  return MODEL_MAPPINGS[modelId]?.provider;
+}
+function getValidModelsForProvider(provider) {
+  return Object.values(MODEL_MAPPINGS).filter((m) => m.provider === provider).map((m) => m.model);
+}
+function getAnthropicModelForModelId(modelId) {
+  const mapping = MODEL_MAPPINGS[modelId];
+  return mapping?.provider === "anthropic" ? mapping.model : void 0;
+}
+function getOpenAIModelForModelId(modelId) {
+  const mapping = MODEL_MAPPINGS[modelId];
+  return mapping?.provider === "openai" ? mapping.model : void 0;
+}
+function getOpenAIApiType(modelId) {
+  const mapping = MODEL_MAPPINGS[modelId];
+  return mapping?.openaiApiType ?? "chat";
+}
+function isResponsesApiModel(modelId) {
+  return getOpenAIApiType(modelId) === "responses";
+}
+var MODEL_ID_TO_ANTHROPIC_MODEL = Object.fromEntries(
+  Object.entries(MODEL_MAPPINGS).filter(([, v]) => v.provider === "anthropic").map(([k, v]) => [k, v.model])
+);
+
+// src/gitlab-openai-language-model.ts
+var GitLabOpenAILanguageModel = class {
+  specificationVersion = "v2";
+  modelId;
+  supportedUrls = {};
+  config;
+  directAccessClient;
+  useResponsesApi;
+  openaiClient = null;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.useResponsesApi = config.useResponsesApi ?? isResponsesApiModel(modelId);
+    this.directAccessClient = new GitLabDirectAccessClient({
+      instanceUrl: config.instanceUrl,
+      getHeaders: config.getHeaders,
+      refreshApiKey: config.refreshApiKey,
+      fetch: config.fetch,
+      featureFlags: config.featureFlags,
+      aiGatewayUrl: config.aiGatewayUrl
+    });
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getOpenAIClient(forceRefresh = false) {
+    const tokenData = await this.directAccessClient.getDirectAccessToken(forceRefresh);
+    const { "x-api-key": _removed, ...filteredHeaders } = tokenData.headers;
+    this.openaiClient = new import_openai.default({
+      apiKey: tokenData.token,
+      baseURL: this.directAccessClient.getOpenAIProxyUrl(),
+      defaultHeaders: filteredHeaders
+    });
+    return this.openaiClient;
+  }
+  isTokenError(error) {
+    if (error instanceof import_openai.default.APIError) {
+      if (error.status === 401) {
+        return true;
+      }
+      const message = error.message?.toLowerCase() || "";
+      if (message.includes("token") && (message.includes("expired") || message.includes("revoked") || message.includes("invalid"))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  convertTools(tools) {
+    if (!tools || tools.length === 0) {
+      return void 0;
+    }
+    return tools.filter((tool) => tool.type === "function").map((tool) => {
+      const schema = tool.inputSchema;
+      return {
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description || "",
+          // Ensure the schema has type: 'object' as OpenAI requires it
+          parameters: {
+            type: "object",
+            ...schema
+          }
+        }
+      };
+    });
+  }
+  convertToolChoice(toolChoice) {
+    if (!toolChoice) {
+      return void 0;
+    }
+    switch (toolChoice.type) {
+      case "auto":
+        return "auto";
+      case "none":
+        return "none";
+      case "required":
+        return "required";
+      case "tool":
+        return { type: "function", function: { name: toolChoice.toolName } };
+      default:
+        return void 0;
+    }
+  }
+  convertPrompt(prompt) {
+    const messages = [];
+    for (const message of prompt) {
+      if (message.role === "system") {
+        messages.push({ role: "system", content: message.content });
+        continue;
+      }
+      if (message.role === "user") {
+        const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text);
+        if (textParts.length > 0) {
+          messages.push({ role: "user", content: textParts.join("\n") });
+        }
+      } else if (message.role === "assistant") {
+        const textParts = [];
+        const toolCalls = [];
+        for (const part of message.content) {
+          if (part.type === "text") {
+            textParts.push(part.text);
+          } else if (part.type === "tool-call") {
+            toolCalls.push({
+              id: part.toolCallId,
+              type: "function",
+              function: {
+                name: part.toolName,
+                arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input)
+              }
+            });
+          }
+        }
+        const assistantMessage = {
+          role: "assistant",
+          content: textParts.length > 0 ? textParts.join("\n") : null
+        };
+        if (toolCalls.length > 0) {
+          assistantMessage.tool_calls = toolCalls;
+        }
+        messages.push(assistantMessage);
+      } else if (message.role === "tool") {
+        for (const part of message.content) {
+          if (part.type === "tool-result") {
+            let resultContent;
+            if (part.output.type === "text") {
+              resultContent = part.output.value;
+            } else if (part.output.type === "json") {
+              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 {
+              resultContent = JSON.stringify(part.output);
+            }
+            messages.push({
+              role: "tool",
+              tool_call_id: part.toolCallId,
+              content: resultContent
+            });
+          }
+        }
+      }
+    }
+    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";
+    }
+  }
+  /**
+   * Convert tools to Responses API format
+   */
+  convertToolsForResponses(tools) {
+    if (!tools || tools.length === 0) {
+      return void 0;
+    }
+    return tools.filter((tool) => tool.type === "function").map((tool) => {
+      const schema = { ...tool.inputSchema };
+      delete schema["$schema"];
+      return {
+        type: "function",
+        name: tool.name,
+        description: tool.description || "",
+        parameters: schema,
+        strict: false
+      };
+    });
+  }
+  /**
+   * Convert prompt to Responses API input format
+   */
+  convertPromptForResponses(prompt) {
+    const items = [];
+    for (const message of prompt) {
+      if (message.role === "system") {
+        continue;
+      }
+      if (message.role === "user") {
+        const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text);
+        if (textParts.length > 0) {
+          items.push({
+            type: "message",
+            role: "user",
+            content: textParts.map((text) => ({ type: "input_text", text }))
+          });
+        }
+      } else if (message.role === "assistant") {
+        const textParts = [];
+        for (const part of message.content) {
+          if (part.type === "text") {
+            textParts.push(part.text);
+          } else if (part.type === "tool-call") {
+            items.push({
+              type: "function_call",
+              call_id: part.toolCallId,
+              name: part.toolName,
+              arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input)
+            });
+          }
+        }
+        if (textParts.length > 0) {
+          items.push({
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: textParts.join("\n"), annotations: [] }]
+          });
+        }
+      } else if (message.role === "tool") {
+        for (const part of message.content) {
+          if (part.type === "tool-result") {
+            let resultContent;
+            if (part.output.type === "text") {
+              resultContent = part.output.value;
+            } else if (part.output.type === "json") {
+              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 {
+              resultContent = JSON.stringify(part.output);
+            }
+            items.push({
+              type: "function_call_output",
+              call_id: part.toolCallId,
+              output: resultContent
+            });
+          }
+        }
+      }
+    }
+    return items;
+  }
+  /**
+   * Extract system instructions from prompt
+   */
+  extractSystemInstructions(prompt) {
+    const systemMessages = prompt.filter((m) => m.role === "system").map((m) => m.content).join("\n");
+    return systemMessages || void 0;
+  }
+  /**
+   * Convert Responses API status to finish reason
+   * Note: Responses API returns 'completed' even when making tool calls,
+   * so we need to check the content for tool calls separately.
+   */
+  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";
+    }
+  }
+  async doGenerate(options) {
+    if (this.useResponsesApi) {
+      return this.doGenerateWithResponsesApi(options, false);
+    }
+    return this.doGenerateWithChatApi(options, false);
+  }
+  async doGenerateWithChatApi(options, isRetry) {
+    const client = await this.getOpenAIClient(isRetry);
+    const messages = this.convertPrompt(options.prompt);
+    const tools = this.convertTools(options.tools);
+    const toolChoice = options.toolChoice?.type !== "none" ? this.convertToolChoice(options.toolChoice) : void 0;
+    const openaiModel = this.config.openaiModel || "gpt-4o";
+    const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    try {
+      const response = await client.chat.completions.create({
+        model: openaiModel,
+        max_completion_tokens: maxTokens,
+        messages,
+        tools,
+        tool_choice: tools ? toolChoice : void 0,
+        temperature: options.temperature,
+        top_p: options.topP,
+        stop: options.stopSequences
+      });
+      const choice = response.choices[0];
+      const content = [];
+      if (choice?.message.content) {
+        content.push({ type: "text", text: choice.message.content });
+      }
+      if (choice?.message.tool_calls) {
+        for (const toolCall of choice.message.tool_calls) {
+          if (toolCall.type === "function") {
+            content.push({
+              type: "tool-call",
+              toolCallId: toolCall.id,
+              toolName: toolCall.function.name,
+              input: toolCall.function.arguments
+            });
+          }
+        }
+      }
+      const usage = {
+        inputTokens: response.usage?.prompt_tokens || 0,
+        outputTokens: response.usage?.completion_tokens || 0,
+        totalTokens: response.usage?.total_tokens || 0
+      };
+      return {
+        content,
+        finishReason: this.convertFinishReason(choice?.finish_reason),
+        usage,
+        warnings: []
+      };
+    } catch (error) {
+      if (!isRetry && this.isTokenError(error)) {
+        this.directAccessClient.invalidateToken();
+        return this.doGenerateWithChatApi(options, true);
+      }
+      if (error instanceof import_openai.default.APIError) {
+        throw new GitLabError({
+          message: `OpenAI API error: ${error.message}`,
+          cause: error
+        });
+      }
+      throw error;
+    }
+  }
+  async doGenerateWithResponsesApi(options, isRetry) {
+    const client = await this.getOpenAIClient(isRetry);
+    const input = this.convertPromptForResponses(options.prompt);
+    const tools = this.convertToolsForResponses(options.tools);
+    const instructions = this.extractSystemInstructions(options.prompt);
+    const openaiModel = this.config.openaiModel || "gpt-5-codex";
+    const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    try {
+      const response = await client.responses.create({
+        model: openaiModel,
+        input,
+        instructions,
+        tools,
+        max_output_tokens: maxTokens,
+        temperature: options.temperature,
+        top_p: options.topP,
+        store: false
+      });
+      const content = [];
+      let hasToolCalls = false;
+      for (const item of response.output || []) {
+        if (item.type === "message" && item.role === "assistant") {
+          for (const contentItem of item.content || []) {
+            if (contentItem.type === "output_text") {
+              content.push({ type: "text", text: contentItem.text });
+            }
+          }
+        } else if (item.type === "function_call") {
+          hasToolCalls = true;
+          content.push({
+            type: "tool-call",
+            toolCallId: item.call_id,
+            toolName: item.name,
+            input: item.arguments
+          });
+        }
+      }
+      const usage = {
+        inputTokens: response.usage?.input_tokens || 0,
+        outputTokens: response.usage?.output_tokens || 0,
+        totalTokens: response.usage?.total_tokens || 0
+      };
+      return {
+        content,
+        finishReason: this.convertResponsesStatus(response.status, hasToolCalls),
+        usage,
+        warnings: []
+      };
+    } catch (error) {
+      if (!isRetry && this.isTokenError(error)) {
+        this.directAccessClient.invalidateToken();
+        return this.doGenerateWithResponsesApi(options, true);
+      }
+      if (error instanceof import_openai.default.APIError) {
+        throw new GitLabError({
+          message: `OpenAI API error: ${error.message}`,
+          cause: error
+        });
+      }
+      throw error;
+    }
+  }
+  async doStream(options) {
+    if (this.useResponsesApi) {
+      return this.doStreamWithResponsesApi(options, false);
+    }
+    return this.doStreamWithChatApi(options, false);
+  }
+  async doStreamWithChatApi(options, isRetry) {
+    const client = await this.getOpenAIClient(isRetry);
+    const messages = this.convertPrompt(options.prompt);
+    const tools = this.convertTools(options.tools);
+    const toolChoice = options.toolChoice?.type !== "none" ? this.convertToolChoice(options.toolChoice) : void 0;
+    const openaiModel = this.config.openaiModel || "gpt-4o";
+    const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    const requestBody = {
+      model: openaiModel,
+      max_completion_tokens: maxTokens,
+      messages,
+      tools,
+      tool_choice: tools ? toolChoice : void 0,
+      temperature: options.temperature,
+      top_p: options.topP,
+      stop: options.stopSequences,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        const toolCalls = {};
+        const usage = {
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0
+        };
+        let finishReason = "unknown";
+        let textStarted = false;
+        const textId = "text-0";
+        try {
+          const openaiStream = await client.chat.completions.create({
+            ...requestBody,
+            stream: true
+          });
+          controller.enqueue({ type: "stream-start", warnings: [] });
+          for await (const chunk of openaiStream) {
+            const choice = chunk.choices?.[0];
+            if (chunk.id && !textStarted) {
+              controller.enqueue({
+                type: "response-metadata",
+                id: chunk.id,
+                modelId: chunk.model
+              });
+            }
+            if (choice?.delta?.content) {
+              if (!textStarted) {
+                controller.enqueue({ type: "text-start", id: textId });
+                textStarted = true;
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: textId,
+                delta: choice.delta.content
+              });
+            }
+            if (choice?.delta?.tool_calls) {
+              for (const tc of choice.delta.tool_calls) {
+                const idx = tc.index;
+                if (!toolCalls[idx]) {
+                  toolCalls[idx] = {
+                    id: tc.id || "",
+                    name: tc.function?.name || "",
+                    arguments: ""
+                  };
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCalls[idx].id,
+                    toolName: toolCalls[idx].name
+                  });
+                }
+                if (tc.function?.arguments) {
+                  toolCalls[idx].arguments += tc.function.arguments;
+                  controller.enqueue({
+                    type: "tool-input-delta",
+                    id: toolCalls[idx].id,
+                    delta: tc.function.arguments
+                  });
+                }
+              }
+            }
+            if (choice?.finish_reason) {
+              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;
+            }
+          }
+          if (textStarted) {
+            controller.enqueue({ type: "text-end", id: textId });
+          }
+          for (const [, tc] of Object.entries(toolCalls)) {
+            controller.enqueue({ type: "tool-input-end", id: tc.id });
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: tc.id,
+              toolName: tc.name,
+              input: tc.arguments || "{}"
+            });
+          }
+          controller.enqueue({ type: "finish", finishReason, usage });
+          controller.close();
+        } catch (error) {
+          if (!isRetry && self.isTokenError(error)) {
+            self.directAccessClient.invalidateToken();
+            controller.enqueue({
+              type: "error",
+              error: new GitLabError({ message: "TOKEN_REFRESH_NEEDED", cause: error })
+            });
+            controller.close();
+            return;
+          }
+          if (error instanceof import_openai.default.APIError) {
+            controller.enqueue({
+              type: "error",
+              error: new GitLabError({
+                message: `OpenAI API error: ${error.message}`,
+                cause: error
+              })
+            });
+          } else {
+            controller.enqueue({ type: "error", error });
+          }
+          controller.close();
+        }
+      }
+    });
+    return { stream, request: { body: requestBody } };
+  }
+  async doStreamWithResponsesApi(options, isRetry) {
+    const client = await this.getOpenAIClient(isRetry);
+    const input = this.convertPromptForResponses(options.prompt);
+    const tools = this.convertToolsForResponses(options.tools);
+    const instructions = this.extractSystemInstructions(options.prompt);
+    const openaiModel = this.config.openaiModel || "gpt-5-codex";
+    const maxTokens = options.maxOutputTokens || this.config.maxTokens || 8192;
+    const requestBody = {
+      model: openaiModel,
+      input,
+      instructions,
+      tools,
+      max_output_tokens: maxTokens,
+      temperature: options.temperature,
+      top_p: options.topP,
+      store: false,
+      stream: true
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        const toolCalls = {};
+        const usage = {
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0
+        };
+        let finishReason = "unknown";
+        let textStarted = false;
+        const textId = "text-0";
+        try {
+          const openaiStream = await client.responses.create({
+            ...requestBody,
+            stream: true
+          });
+          controller.enqueue({ type: "stream-start", warnings: [] });
+          for await (const event of openaiStream) {
+            if (event.type === "response.created") {
+              controller.enqueue({
+                type: "response-metadata",
+                id: event.response.id,
+                modelId: event.response.model
+              });
+            } else if (event.type === "response.output_item.added") {
+              if (event.item.type === "function_call") {
+                const outputIndex = event.output_index;
+                const callId = event.item.call_id;
+                toolCalls[outputIndex] = {
+                  callId,
+                  name: event.item.name,
+                  arguments: ""
+                };
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: callId,
+                  toolName: event.item.name
+                });
+              }
+            } else if (event.type === "response.output_text.delta") {
+              if (!textStarted) {
+                controller.enqueue({ type: "text-start", id: textId });
+                textStarted = true;
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: textId,
+                delta: event.delta
+              });
+            } else if (event.type === "response.function_call_arguments.delta") {
+              const outputIndex = event.output_index;
+              const tc = toolCalls[outputIndex];
+              if (tc) {
+                tc.arguments += event.delta;
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: tc.callId,
+                  delta: event.delta
+                });
+              }
+            } else if (event.type === "response.function_call_arguments.done") {
+              const outputIndex = event.output_index;
+              const tc = toolCalls[outputIndex];
+              if (tc) {
+                tc.arguments = event.arguments;
+              }
+            } else if (event.type === "response.completed") {
+              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;
+              }
+            }
+          }
+          if (textStarted) {
+            controller.enqueue({ type: "text-end", id: textId });
+          }
+          const hasToolCalls = Object.keys(toolCalls).length > 0;
+          if (hasToolCalls && finishReason === "stop") {
+            finishReason = "tool-calls";
+          }
+          for (const tc of Object.values(toolCalls)) {
+            controller.enqueue({ type: "tool-input-end", id: tc.callId });
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: tc.callId,
+              toolName: tc.name,
+              input: tc.arguments || "{}"
+            });
+          }
+          controller.enqueue({ type: "finish", finishReason, usage });
+          controller.close();
+        } catch (error) {
+          if (!isRetry && self.isTokenError(error)) {
+            self.directAccessClient.invalidateToken();
+            controller.enqueue({
+              type: "error",
+              error: new GitLabError({ message: "TOKEN_REFRESH_NEEDED", cause: error })
+            });
+            controller.close();
+            return;
+          }
+          if (error instanceof import_openai.default.APIError) {
+            controller.enqueue({
+              type: "error",
+              error: new GitLabError({
+                message: `OpenAI API error: ${error.message}`,
+                cause: error
+              })
+            });
+          } else {
+            controller.enqueue({ type: "error", error });
+          }
+          controller.close();
+        }
+      }
+    });
+    return { stream, request: { body: requestBody } };
+  }
+};
+
 // src/gitlab-oauth-types.ts
 var BUNDLED_CLIENT_ID = "36f2a70cddeb5a0889d4fd8295c241b7e9848e89cf9e599d0eed2d8e5350fbf5";
 var GITLAB_COM_URL = "https://gitlab.com";
@@ -775,16 +1558,6 @@ var GitLabOAuthManager = class {
   }
 };
 
-// src/model-mappings.ts
-var MODEL_ID_TO_ANTHROPIC_MODEL = {
-  "duo-chat-opus-4-5": "claude-opus-4-5-20251101",
-  "duo-chat-sonnet-4-5": "claude-sonnet-4-5-20250929",
-  "duo-chat-haiku-4-5": "claude-haiku-4-5-20251001"
-};
-function getAnthropicModelForModelId(modelId) {
-  return MODEL_ID_TO_ANTHROPIC_MODEL[modelId];
-}
-
 // src/gitlab-provider.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
@@ -920,21 +1693,44 @@ function createGitLab(options = {}) {
   getApiKey().catch(() => {
   });
   const createAgenticChatModel = (modelId, agenticOptions) => {
+    const mapping = getModelMapping(modelId);
+    if (!mapping) {
+      throw new GitLabError({
+        message: `Unknown model ID: ${modelId}. Model must be registered in MODEL_MAPPINGS.`
+      });
+    }
+    if (agenticOptions?.providerModel) {
+      const validModels = getValidModelsForProvider(mapping.provider);
+      if (!validModels.includes(agenticOptions.providerModel)) {
+        throw new GitLabError({
+          message: `Invalid providerModel '${agenticOptions.providerModel}' for provider '${mapping.provider}'. Valid models: ${validModels.join(", ")}`
+        });
+      }
+    }
     const featureFlags = {
       DuoAgentPlatformNext: true,
       ...options.featureFlags,
       ...agenticOptions?.featureFlags
     };
-    return new GitLabAgenticLanguageModel(modelId, {
+    const baseConfig = {
       provider: `${providerName}.agentic`,
       instanceUrl,
       getHeaders,
       refreshApiKey,
       fetch: options.fetch,
-      anthropicModel: agenticOptions?.anthropicModel ?? getAnthropicModelForModelId(modelId),
       maxTokens: agenticOptions?.maxTokens,
       featureFlags,
       aiGatewayUrl: options.aiGatewayUrl
+    };
+    if (mapping.provider === "openai") {
+      return new GitLabOpenAILanguageModel(modelId, {
+        ...baseConfig,
+        openaiModel: agenticOptions?.providerModel ?? mapping.model
+      });
+    }
+    return new GitLabAnthropicLanguageModel(modelId, {
+      ...baseConfig,
+      anthropicModel: agenticOptions?.providerModel ?? mapping.model
     });
   };
   const createDefaultModel = (modelId) => {
@@ -1045,7 +1841,7 @@ var GitLabProjectCache = class {
 };
 
 // src/gitlab-project-detector.ts
-var debugLog2 = (..._args) => {
+var debugLog = (..._args) => {
 };
 var GitLabProjectDetector = class {
   config;
@@ -1074,35 +1870,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;
     }
@@ -1234,17 +2030,25 @@ var GitLabProjectDetector = class {
   BUNDLED_CLIENT_ID,
   DEFAULT_AI_GATEWAY_URL,
   GITLAB_COM_URL,
-  GitLabAgenticLanguageModel,
+  GitLabAnthropicLanguageModel,
   GitLabDirectAccessClient,
   GitLabError,
   GitLabOAuthManager,
+  GitLabOpenAILanguageModel,
   GitLabProjectCache,
   GitLabProjectDetector,
   MODEL_ID_TO_ANTHROPIC_MODEL,
+  MODEL_MAPPINGS,
   OAUTH_SCOPES,
   TOKEN_EXPIRY_SKEW_MS,
   createGitLab,
   getAnthropicModelForModelId,
-  gitlab
+  getModelMapping,
+  getOpenAIApiType,
+  getOpenAIModelForModelId,
+  getProviderForModelId,
+  getValidModelsForProvider,
+  gitlab,
+  isResponsesApiModel
 });
 //# sourceMappingURL=index.js.map