import { Anthropic } from "@anthropic-ai/sdk" import OpenAI, { AzureOpenAI } from "openai" import axios from "axios" import { type ModelInfo, azureOpenAiDefaultApiVersion, isAzureAiInferenceBaseUrl, isAzureOpenAiBaseUrl, openAiModelInfoSaneDefaults, DEEP_SEEK_DEFAULT_TEMPERATURE, DEFAULT_OPEN_AI_STRICT_TOOL_SCHEMAS, OPENAI_AZURE_AI_INFERENCE_PATH, parseOpenAiExtraBody, } from "@roo-code/types" import type { ApiHandlerOptions } from "../../shared/api" import { TagMatcher } from "../../utils/tag-matcher" import { convertToOpenAiMessages } from "../transform/openai-format" import { sanitizeSurrogates } from "../transform/sanitize-surrogates" import { convertToR1Format } from "../transform/r1-format" import { ApiStream, ApiStreamUsageChunk } from "../transform/stream" import { getModelParams } from "../transform/model-params" import { DEFAULT_HEADERS, NOT_PROVIDED } from "./constants" import { BaseProvider } from "./base-provider" import type { SingleCompletionHandler, ApiHandlerCreateMessageMetadata, CompletePromptOptions } from "../index" import { handleOpenAIRequestError } from "./utils/error-handler" import { extractReasoningFromDelta } from "./utils/extract-reasoning" import { RequestConfigBuilder } from "./config-builder/request-config-builder" import { createAbortError, mergeAbortSignalAndTimeout, throwIfAborted } from "./utils/abort-signal" import { getRequestTimeoutMs } from "./utils/request-timeout" /** Subset of OpenAI.RequestOptions built per request for the abort-signal wiring. */ type OpenAiRequestConfig = { path?: string signal?: AbortSignal /** Per-request SDK timeout; a positive timeoutMs overrides the client default. */ timeout?: number } type OpenAiUsage = | { prompt_tokens?: number completion_tokens?: number cache_creation_input_tokens?: number cache_read_input_tokens?: unknown prompt_tokens_details?: { cached_tokens?: unknown } | null } | null | undefined // TODO: Rename this to OpenAICompatibleHandler. Also, I think the // `OpenAINativeHandler` can subclass from this, since it's obviously // compatible with the OpenAI API. We can also rename it to `OpenAIHandler`. export class OpenAiHandler extends BaseProvider implements SingleCompletionHandler { protected options: ApiHandlerOptions protected client: OpenAI private readonly providerName = "OpenAI" private readonly extraBody: Record constructor(options: ApiHandlerOptions) { super() this.options = options this.extraBody = parseOpenAiExtraBody(options.openAiExtraBody).data const baseURL = this.options.openAiBaseUrl || "https://api.openai.com/v1" const apiKey = this.options.openAiApiKey ?? NOT_PROVIDED const isAzureAiInference = this._isAzureAiInference(this.options.openAiBaseUrl) const isAzureOpenAi = isAzureOpenAiBaseUrl(this.options.openAiBaseUrl, options.openAiUseAzure) const headers = { ...DEFAULT_HEADERS, ...(this.options.openAiHeaders || {}), } if (isAzureAiInference) { // Azure AI Inference Service (e.g., for DeepSeek) uses a different path structure this.client = new OpenAI({ baseURL, apiKey, defaultHeaders: headers, defaultQuery: { "api-version": this.options.azureApiVersion || "2024-05-01-preview" }, timeout: this.timeoutMs, }) } else if (isAzureOpenAi) { // Azure API shape slightly differs from the core API shape: // https://github.com/openai/openai-node?tab=readme-ov-file#microsoft-azure-openai const azureBaseURL = `${baseURL.replace(/\/openai\/?$/i, "").replace(/\/$/, "")}/openai` this.client = new AzureOpenAI({ baseURL: azureBaseURL, apiKey, apiVersion: this.options.azureApiVersion || azureOpenAiDefaultApiVersion, defaultHeaders: headers, timeout: this.timeoutMs, }) } else { this.client = new OpenAI({ baseURL, apiKey, defaultHeaders: headers, timeout: this.timeoutMs, }) } } override async *createMessage( systemPrompt: string, messages: Anthropic.Messages.MessageParam[], metadata?: ApiHandlerCreateMessageMetadata, ): ApiStream { throwIfAborted(metadata?.abortSignal) const signal = metadata?.abortSignal const { info: modelInfo, reasoning } = this.getModel() const modelUrl = this.options.openAiBaseUrl ?? "" const modelId = this.options.openAiModelId ?? "" // yield undefined, which the parameter default in convertToolsForOpenAI turns back into const strictToolSchemas = this.options.openAiStrictToolSchemas ?? DEFAULT_OPEN_AI_STRICT_TOOL_SCHEMAS const isAzureAiInference = this._isAzureAiInference(modelUrl) const deepseekReasoner = this.usesR1Format(modelId) if (modelId.includes("o1") || modelId.includes("o3") || modelId.includes("o4")) { yield* this.handleO3FamilyMessage(modelId, systemPrompt, messages, metadata) return } let systemMessage: OpenAI.Chat.ChatCompletionSystemMessageParam = { role: "system", // Sanitize lone UTF-16 surrogates: providers validating the JSON body // (e.g. DeepSeek) reject the whole request otherwise. See #461. content: sanitizeSurrogates(systemPrompt), } if (this.options.openAiStreamingEnabled ?? true) { let convertedMessages if (deepseekReasoner) { convertedMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages]) } else { if (modelInfo.supportsPromptCache) { systemMessage = { role: "system", content: [ { type: "text", text: sanitizeSurrogates(systemPrompt), // @ts-ignore-next-line cache_control: { type: "ephemeral" }, }, ], } } convertedMessages = [systemMessage, ...convertToOpenAiMessages(messages)] if (modelInfo.supportsPromptCache) { // Note: the following logic is copied from openrouter: // Add cache_control to the last two user messages // (note: this works because we only ever add one user message at a time, but if we added multiple we'd need to mark the user message before the last assistant message) const lastTwoUserMessages = convertedMessages.filter((msg) => msg.role === "user").slice(-2) lastTwoUserMessages.forEach((msg) => { if (typeof msg.content === "string") { msg.content = [{ type: "text", text: msg.content }] } if (Array.isArray(msg.content)) { // NOTE: this is fine since env details will always be added at the end. but if it weren't there, and the user added a image_url type message, it would pop a text part before it and then move it after to the end. let lastTextPart = msg.content.filter((part) => part.type === "text").pop() if (!lastTextPart) { lastTextPart = { type: "text", text: "..." } msg.content.push(lastTextPart) } // @ts-ignore-next-line lastTextPart["cache_control"] = { type: "ephemeral" } } }) } } const isGrokXAI = this._isGrokXAI(this.options.openAiBaseUrl) let requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming = { model: modelId, // Some OpenAI-Compatible models (e.g. claude-opus-4-7, claude-opus-4-8) reject // `temperature` as deprecated/unsupported, so honor the model's `supportsTemperature` // flag and omit it when that flag is false. Beyond that, only send `temperature` when // the user set a custom value or the model needs a specific default (deepseek-reasoner); // otherwise omit it so the server's own default applies instead of forcing 0. ...(modelInfo.supportsTemperature !== false && (this.options.modelTemperature != null || deepseekReasoner) && { temperature: this.options.modelTemperature ?? DEEP_SEEK_DEFAULT_TEMPERATURE, }), messages: convertedMessages, stream: true as const, ...(isGrokXAI ? {} : { stream_options: { include_usage: true } }), ...(reasoning && reasoning), tools: this.convertToolsForOpenAI(metadata?.tools, strictToolSchemas), tool_choice: metadata?.tool_choice, parallel_tool_calls: metadata?.parallelToolCalls ?? true, } // Add max_tokens if needed this.addMaxTokensIfNeeded(requestOptions, modelInfo) requestOptions = this.withExtraBody(requestOptions) let stream try { stream = await this.client.chat.completions.create( requestOptions, this.buildChatRequestConfig(isAzureAiInference, metadata), ) } catch (error) { throw handleOpenAIRequestError(error, this.providerName, metadata?.abortSignal) } const matcher = new TagMatcher( ["think", "thought"], (chunk) => ({ type: chunk.matched ? "reasoning" : "text", text: chunk.data, }) as const, ) let lastUsage const activeToolCallIds = new Set() try { for await (const chunk of stream) { // Streaming-loop abort defense: the for-await above already pulled this // chunk; the top-of-loop break stops *processing* (and yielding) buffered // content that arrived after the caller's signal aborted. if (signal?.aborted) { break } const delta = chunk.choices?.[0]?.delta ?? {} const finishReason = chunk.choices?.[0]?.finish_reason const reasoningText = extractReasoningFromDelta(delta) if (reasoningText) { yield { type: "reasoning", text: reasoningText } } if (delta.content) { for (const chunk of matcher.update(delta.content)) { // Same-chunk abort defense: the reasoning yield above may already have been // the last event the caller wanted, so the signal is re-read between the yields a // single chunk produces instead of only between chunks. if (signal?.aborted) { break } yield chunk } } yield* this.processToolCalls(delta, finishReason, activeToolCallIds, signal) if (chunk.usage) { lastUsage = chunk.usage } } } catch (error) { // The creation-site catch does not cover errors raised by the async // iterator itself (e.g. a mid-stream abort); normalize them the same way. throw handleOpenAIRequestError(error, this.providerName, metadata?.abortSignal) } // Post-loop abort defense: a signal that aborted while the loop was running must // surface the Task.ts abort contract instead of letting the stream end normally // with the buffered matcher/usage content below. if (signal?.aborted) { throw handleOpenAIRequestError(createAbortError(this.providerName), this.providerName, signal) } for (const chunk of matcher.final()) { yield chunk } if (lastUsage) { yield this.processUsageMetrics(lastUsage, modelInfo) } } else { let requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = { model: modelId, messages: deepseekReasoner ? convertToR1Format([{ role: "user", content: systemPrompt }, ...messages]) : [systemMessage, ...convertToOpenAiMessages(messages)], ...reasoning, // Tools are always present (minimum ALWAYS_AVAILABLE_TOOLS) tools: this.convertToolsForOpenAI(metadata?.tools, strictToolSchemas), tool_choice: metadata?.tool_choice, parallel_tool_calls: metadata?.parallelToolCalls ?? true, } // Add max_tokens if needed this.addMaxTokensIfNeeded(requestOptions, modelInfo) requestOptions = this.withExtraBody(requestOptions) let response try { response = await this.client.chat.completions.create( requestOptions, this.buildChatRequestConfig(this._isAzureAiInference(modelUrl), metadata), ) } catch (error) { throw handleOpenAIRequestError(error, this.providerName, metadata?.abortSignal) } // A cancellation that lands while the response is in flight must not be reported as // completed work: the arrived text and tool calls are discarded and the abort contract // is raised instead, so Task.ts never sees content the caller already cancelled. if (signal?.aborted) { throw handleOpenAIRequestError(createAbortError(this.providerName), this.providerName, signal) } const message = response.choices?.[0]?.message if (message?.tool_calls) { for (const toolCall of message.tool_calls) { if (toolCall.type === "function") { yield { type: "tool_call", id: toolCall.id, name: toolCall.function.name, arguments: toolCall.function.arguments, } } } } yield { type: "text", text: message?.content || "", } yield this.processUsageMetrics(response.usage, modelInfo) } } protected processUsageMetrics(usage: OpenAiUsage, _modelInfo?: ModelInfo): ApiStreamUsageChunk { const inputTokens = usage?.prompt_tokens || 0 const reportedCacheReadTokens = usage?.cache_read_input_tokens ?? usage?.prompt_tokens_details?.cached_tokens const cacheReadTokens = typeof reportedCacheReadTokens === "number" && Number.isFinite(reportedCacheReadTokens) && Number.isInteger(reportedCacheReadTokens) && reportedCacheReadTokens >= 0 && // Proxy-specific counters may exclude cache reads from prompt_tokens. // Only OpenAI's nested cached_tokens must be a subset of prompt_tokens. (usage?.cache_read_input_tokens != null || reportedCacheReadTokens <= inputTokens) ? reportedCacheReadTokens || undefined : undefined return { type: "usage", inputTokens, outputTokens: usage?.completion_tokens || 0, cacheWriteTokens: usage?.cache_creation_input_tokens || undefined, cacheReadTokens, } } // Single gate for everything that depends on the R1 request format: message // conversion in createMessage() and reasoning retention in getModel(). Both // must agree, otherwise reasoning is converted for the request but stripped // from the follow-up context (or vice versa). private usesR1Format(modelId: string): boolean { return modelId.includes("deepseek-reasoner") || (this.options.openAiR1FormatEnabled ?? false) } override getModel() { const id = this.options.openAiModelId ?? "" const info: ModelInfo = this.options.openAiCustomModelInfo ?? openAiModelInfoSaneDefaults const params = getModelParams({ format: "openai", modelId: id, model: info, // OpenAI Compatible edits effort in custom model info. The shared top-level // setting may be left over from another provider and must not override it. settings: { ...this.options, reasoningEffort: info.reasoningEffort }, defaultTemperature: 0, }) // Local OpenAI-compatible reasoning models (llama.cpp, LM Studio, Ollama) // stream reasoning_content, but Zoo Code strips it from the follow-up context // unless info.preserveReasoning is set. Whenever createMessage() treats the // model as R1 (deepseek-reasoner id or the R1 format toggle), also treat it // as preserving reasoning so the chain is fed back. return { id, info: this.usesR1Format(id) ? { ...info, preserveReasoning: true } : info, ...params, } } async completePrompt(prompt: string, options?: CompletePromptOptions): Promise { throwIfAborted(options?.abortSignal) try { const isAzureAiInference = this._isAzureAiInference(this.options.openAiBaseUrl) const model = this.getModel() const modelInfo = model.info let requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = { model: model.id, messages: [{ role: "user", content: prompt }], ...model.reasoning, } // Add max_tokens if needed this.addMaxTokensIfNeeded(requestOptions, modelInfo) requestOptions = this.withExtraBody(requestOptions) let response const requestConfig = this.buildCompletePromptRequestConfig(isAzureAiInference, options) try { response = await this.client.chat.completions.create(requestOptions, requestConfig) } catch (error) { throw handleOpenAIRequestError( error, this.providerName, options?.abortSignal, requestConfig.signal ?? undefined, ) } // A cancellation that lands while the response is in flight must not be reported as a // completed prompt: the answer is discarded and the abort contract is raised instead. if (options?.abortSignal?.aborted) { throw handleOpenAIRequestError( createAbortError(this.providerName), this.providerName, options.abortSignal, requestConfig.signal ?? undefined, ) } return response.choices?.[0]?.message.content || "" } catch (error) { if (error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")) { // Preserve the normalized abort or timeout error (name + message contract) as-is. throw error } if (error instanceof Error) { const wrapped = new Error(`${this.providerName} completion error: ${error.message}`, { cause: error }) const source = error as Error & { status?: number; errorDetails?: unknown; code?: unknown } const target = wrapped as Error & { status?: number; errorDetails?: unknown; code?: unknown } if (source.status !== undefined) target.status = source.status if (source.errorDetails !== undefined) target.errorDetails = source.errorDetails if (source.code !== undefined) target.code = source.code throw wrapped } throw error } } /** * Builds the per-request OpenAI SDK options for a chat completions create * (createMessage paths): the Azure AI Inference path when applicable, plus * the caller's abort signal, via RequestConfigBuilder adoption. */ private buildChatRequestConfig( isAzureAiInference: boolean, metadata?: ApiHandlerCreateMessageMetadata, ): OpenAI.RequestOptions { return ( new RequestConfigBuilder() .setOption("path", isAzureAiInference ? OPENAI_AZURE_AI_INFERENCE_PATH : undefined) .setAbortSignal(metadata) .build() ?? {} ) } /** * Builds the per-request options for completePrompt. CompletePromptOptions * is not ApiHandlerCreateMessageMetadata (required taskId), so the merged * abort/timeout signal and the per-request SDK timeout (a positive timeoutMs * overrides the client-level default) go through setOption instead of * setAbortSignal. */ private buildCompletePromptRequestConfig( isAzureAiInference: boolean, options?: CompletePromptOptions, ): OpenAI.RequestOptions { const requestTimeout = getRequestTimeoutMs(options?.timeoutMs) return ( new RequestConfigBuilder() .setOption("path", isAzureAiInference ? OPENAI_AZURE_AI_INFERENCE_PATH : undefined) .setOption("signal", mergeAbortSignalAndTimeout(options?.abortSignal, options?.timeoutMs)) .setOption("timeout", requestTimeout) .build() ?? {} ) } private async *handleO3FamilyMessage( modelId: string, systemPrompt: string, messages: Anthropic.Messages.MessageParam[], metadata?: ApiHandlerCreateMessageMetadata, ): ApiStream { const { info: modelInfo, reasoning } = this.getModel() const methodIsAzureAiInference = this._isAzureAiInference(this.options.openAiBaseUrl) // yield undefined, which the parameter default in convertToolsForOpenAI turns back into const strictToolSchemas = this.options.openAiStrictToolSchemas ?? DEFAULT_OPEN_AI_STRICT_TOOL_SCHEMAS const signal = metadata?.abortSignal if (this.options.openAiStreamingEnabled ?? true) { const isGrokXAI = this._isGrokXAI(this.options.openAiBaseUrl) let requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming = { model: modelId, messages: [ { role: "developer", content: sanitizeSurrogates(`Formatting re-enabled\n${systemPrompt}`), }, ...convertToOpenAiMessages(messages), ], stream: true, ...(isGrokXAI ? {} : { stream_options: { include_usage: true } }), ...reasoning, temperature: undefined, // Tools are always present (minimum ALWAYS_AVAILABLE_TOOLS) tools: this.convertToolsForOpenAI(metadata?.tools, strictToolSchemas), tool_choice: metadata?.tool_choice, parallel_tool_calls: metadata?.parallelToolCalls ?? true, } // O3 family models do not support the deprecated max_tokens parameter // but they do support max_completion_tokens (the modern OpenAI parameter) // This allows O3 models to limit response length when includeMaxTokens is enabled this.addMaxTokensIfNeeded(requestOptions, modelInfo) requestOptions = this.withExtraBody(requestOptions) let stream try { stream = await this.client.chat.completions.create( requestOptions, this.buildChatRequestConfig(methodIsAzureAiInference, metadata), ) } catch (error) { throw handleOpenAIRequestError(error, this.providerName, metadata?.abortSignal) } try { yield* this.handleStreamResponse(stream, signal) } catch (error) { // The creation-site catch does not cover errors raised by the async // iterator itself (e.g. a mid-stream abort); normalize them the same way. throw handleOpenAIRequestError(error, this.providerName, signal) } // Post-loop abort defense: a signal that aborted while the loop was running // must surface the Task.ts abort contract instead of letting the stream end // normally with the buffered content it may have pulled. if (signal?.aborted) { throw handleOpenAIRequestError(createAbortError(this.providerName), this.providerName, signal) } } else { let requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = { model: modelId, messages: [ { role: "developer", content: sanitizeSurrogates(`Formatting re-enabled\n${systemPrompt}`), }, ...convertToOpenAiMessages(messages), ], ...reasoning, temperature: undefined, // Tools are always present (minimum ALWAYS_AVAILABLE_TOOLS) tools: this.convertToolsForOpenAI(metadata?.tools, strictToolSchemas), tool_choice: metadata?.tool_choice, parallel_tool_calls: metadata?.parallelToolCalls ?? true, } // O3 family models do not support the deprecated max_tokens parameter // but they do support max_completion_tokens (the modern OpenAI parameter) // This allows O3 models to limit response length when includeMaxTokens is enabled this.addMaxTokensIfNeeded(requestOptions, modelInfo) requestOptions = this.withExtraBody(requestOptions) let response try { response = await this.client.chat.completions.create( requestOptions, this.buildChatRequestConfig(methodIsAzureAiInference, metadata), ) } catch (error) { throw handleOpenAIRequestError(error, this.providerName, metadata?.abortSignal) } // A cancellation that lands while the response is in flight must not be reported as // completed work: the arrived text and tool calls are discarded and the abort contract // is raised instead, so Task.ts never sees content the caller already cancelled. if (signal?.aborted) { throw handleOpenAIRequestError(createAbortError(this.providerName), this.providerName, signal) } const message = response.choices?.[0]?.message if (message?.tool_calls) { for (const toolCall of message.tool_calls) { if (toolCall.type === "function") { yield { type: "tool_call", id: toolCall.id, name: toolCall.function.name, arguments: toolCall.function.arguments, } } } } yield { type: "text", text: message?.content || "", } yield this.processUsageMetrics(response.usage) } } private async *handleStreamResponse( stream: AsyncIterable, signal?: AbortSignal, ): ApiStream { const activeToolCallIds = new Set() for await (const chunk of stream) { // Streaming-loop abort defense: the for-await above already pulled this // chunk; the top-of-loop break stops *processing* (and yielding) buffered // content that arrived after the caller's signal aborted. if (signal?.aborted) { break } const delta = chunk.choices?.[0]?.delta const finishReason = chunk.choices?.[0]?.finish_reason if (delta) { if (delta.content) { yield { type: "text", text: delta.content, } } yield* this.processToolCalls(delta, finishReason, activeToolCallIds, signal) } if (chunk.usage) { yield this.processUsageMetrics(chunk.usage) } } } /** * Helper generator to process tool calls from a stream chunk. * Tracks active tool call IDs and yields tool_call_partial and tool_call_end events. * @param delta - The delta object from the stream chunk * @param finishReason - The finish_reason from the stream chunk * @param activeToolCallIds - Set to track active tool call IDs (mutated in place) * @param signal - Caller abort signal, re-read before each yield so a cancelled caller stops * receiving tool-call events instead of draining the ones that already arrived */ protected *processToolCalls( delta: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta | undefined, finishReason: string | null | undefined, activeToolCallIds: Set, signal?: AbortSignal, ): Generator< | { type: "tool_call_partial"; index: number; id?: string; name?: string; arguments?: string } | { type: "tool_call_end"; id: string } > { if (delta?.tool_calls) { for (const toolCall of delta.tool_calls) { if (toolCall.id) { activeToolCallIds.add(toolCall.id) } // A cancelled caller must not receive tool-call partials that arrived after the // cancellation; the guard is read before the yield, not after it. if (signal?.aborted) { break } yield { type: "tool_call_partial", index: toolCall.index, id: toolCall.id, name: toolCall.function?.name, arguments: toolCall.function?.arguments, } } } // Emit tool_call_end events when finish_reason is "tool_calls" // This ensures tool calls are finalized even if the stream doesn't properly close if (finishReason === "tool_calls" && activeToolCallIds.size > 0) { for (const id of activeToolCallIds) { if (signal?.aborted) { break } yield { type: "tool_call_end", id } } activeToolCallIds.clear() } } protected _getUrlHost(baseUrl?: string): string { try { return new URL(baseUrl ?? "").hostname } catch { return "" } } private _isGrokXAI(baseUrl?: string): boolean { const urlHost = this._getUrlHost(baseUrl) return urlHost === "api.x.ai" || urlHost.endsWith(".x.ai") } protected _isAzureAiInference(baseUrl?: string): boolean { return isAzureAiInferenceBaseUrl(baseUrl) } /** * Adds max_completion_tokens to the request body if needed based on provider configuration * Note: max_tokens is deprecated in favor of max_completion_tokens as per OpenAI documentation * O3 family models handle max_tokens separately in handleO3FamilyMessage */ protected addMaxTokensIfNeeded( requestOptions: | OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming | OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming, modelInfo: ModelInfo, ): void { // Only add max_completion_tokens if includeMaxTokens is true if (this.options.includeMaxTokens === true) { // Use user-configured modelMaxTokens if available, otherwise fall back to model's default maxTokens // Using max_completion_tokens as max_tokens is deprecated requestOptions.max_completion_tokens = this.options.modelMaxTokens || modelInfo.maxTokens } } private withExtraBody(requestOptions: T): T { return { ...this.extraBody, ...requestOptions } } } export async function getOpenAiModels(baseUrl?: string, apiKey?: string, openAiHeaders?: Record) { try { if (!baseUrl) { return [] } // Trim whitespace from baseUrl to handle cases where users accidentally include spaces const trimmedBaseUrl = baseUrl.trim() if (!URL.canParse(trimmedBaseUrl)) { return [] } const config: Record = {} const headers: Record = { ...DEFAULT_HEADERS, ...(openAiHeaders || {}), } if (apiKey) { headers["Authorization"] = `Bearer ${apiKey}` } if (Object.keys(headers).length > 0) { config["headers"] = headers } const response = await axios.get(`${trimmedBaseUrl}/models`, config) const modelsArray = response.data?.data?.map((model: any) => model.id) || [] return [...new Set(modelsArray)] } catch { return [] } }