refactor: Rename openAIV3Provider to completions

Rename openai_v3_internal.go to openai_completions_internal.go
and the provider struct from openAIV3Provider to
openAICompletionsProvider to align with the existing
openai_responses_internal.go naming convention.

Shared types (openAIV3ModelParams, ResponseFormat,
CompletionHandler) are unchanged as they serve both the
Chat Completions and Responses API providers.

Author: petmal

providers/alibaba.go

@@ -22,7 +22,7 @@ func NewAlibaba(cfg config.AlibabaClientConfig, availableTools []config.ToolConf
 		option.WithAPIKey(cfg.APIKey),
 		option.WithBaseURL(cfg.GetEndpoint()),
 	}
-	openaiProvider := newOpenAIV3Provider(availableTools, openAIV3Opts...)
+	openaiProvider := newOpenAICompletionsProvider(availableTools, openAIV3Opts...)
 
 	return &Alibaba{openaiProvider: openaiProvider}
 }
@@ -31,7 +31,7 @@ func NewAlibaba(cfg config.AlibabaClientConfig, availableTools []config.ToolConf
 // The Qwen models from Alibaba Cloud support OpenAI-compatible interfaces
 // allowing them to be used with the existing OpenAI provider implementation.
 type Alibaba struct {
-	openaiProvider *openAIV3Provider
+	openaiProvider *openAICompletionsProvider
 }
 
 func (a Alibaba) Name() string {

providers/moonshotai.go

@@ -27,7 +27,7 @@ func NewMoonshotAI(cfg config.MoonshotAIClientConfig, availableTools []config.To
 		option.WithAPIKey(cfg.APIKey),
 		option.WithBaseURL(cfg.GetEndpoint()),
 	}
-	openaiProvider := newOpenAIV3Provider(availableTools, openAIV3Opts...)
+	openaiProvider := newOpenAICompletionsProvider(availableTools, openAIV3Opts...)
 	openaiProvider.NewCompletionHandler = func() CompletionHandler {
 		return &moonshotAICompletionHandler{}
 	}
@@ -39,7 +39,7 @@ func NewMoonshotAI(cfg config.MoonshotAIClientConfig, availableTools []config.To
 // The Kimi models from Moonshot AI support OpenAI-compatible interfaces
 // allowing them to be used with the existing OpenAI provider implementation.
 type MoonshotAI struct {
-	openaiProvider *openAIV3Provider
+	openaiProvider *openAICompletionsProvider
 }
 
 func (m MoonshotAI) Name() string {

providers/openai.go

@@ -23,14 +23,14 @@ import (
 func NewOpenAI(cfg config.OpenAIClientConfig, availableTools []config.ToolConfig) *OpenAI {
 	opts := []option.RequestOption{option.WithAPIKey(cfg.APIKey)}
 	return &OpenAI{
-		completionProvider: newOpenAIV3Provider(availableTools, opts...),
+		completionProvider: newOpenAICompletionsProvider(availableTools, opts...),
 		responsesProvider:  newOpenAIResponsesProvider(availableTools, opts...),
 	}
 }
 
 // OpenAI implements the Provider interface for OpenAI generative models.
 type OpenAI struct {
-	completionProvider *openAIV3Provider
+	completionProvider *openAICompletionsProvider
 	responsesProvider  *openAIResponsesProvider
 }
 

providers/openai_v3_internal.go providers/openai_completions_internal.goproviders/openai_v3_internal.go renamed to providers/openai_completions_internal.go

@@ -78,9 +78,9 @@ func (h *defaultCompletionHandler) ToParam(_ context.Context, _ logging.Logger,
 	return message.ToParam()
 }
 
-// openAIV3Provider is an OpenAI-compatible provider implementation using
-// OpenAI's official Go SDK v3.
-type openAIV3Provider struct {
+// openAICompletionsProvider is an OpenAI-compatible Chat Completions API
+// provider implementation using OpenAI's official Go SDK v3.
+type openAICompletionsProvider struct {
 	client         openai.Client
 	availableTools []config.ToolConfig
 
@@ -90,7 +90,7 @@ type openAIV3Provider struct {
 	NewCompletionHandler func() CompletionHandler
 }
 
-// openAIV3ModelParams is an internal model configuration used by openAIV3Provider.
+// openAIV3ModelParams is an internal model configuration used by OpenAI implementations.
 // It is not user-facing; provider wrappers translate their user-facing model params
 // into this struct.
 type openAIV3ModelParams struct {
@@ -144,18 +144,18 @@ func (r ResponseFormat) Ptr() *ResponseFormat {
 	return utils.Ptr(r)
 }
 
-func newOpenAIV3Provider(availableTools []config.ToolConfig, opts ...option.RequestOption) *openAIV3Provider {
+func newOpenAICompletionsProvider(availableTools []config.ToolConfig, opts ...option.RequestOption) *openAICompletionsProvider {
 	clientOpts := append([]option.RequestOption{
 		option.WithMaxRetries(0), // disable SDK retries since MindTrial has its own retry policy
 	}, opts...)
 
-	return &openAIV3Provider{
+	return &openAICompletionsProvider{
 		client:         openai.NewClient(clientOpts...),
 		availableTools: availableTools,
 	}
 }
 
-func (o *openAIV3Provider) Run(ctx context.Context, logger logging.Logger, cfg config.RunConfig, task config.Task) (result Result, err error) {
+func (o *openAICompletionsProvider) Run(ctx context.Context, logger logging.Logger, cfg config.RunConfig, task config.Task) (result Result, err error) {
 	request := openai.ChatCompletionNewParams{
 		Model:    openai.ChatModel(cfg.Model),
 		Messages: []openai.ChatCompletionMessageParamUnion{},
@@ -370,7 +370,7 @@ func (o *openAIV3Provider) Run(ctx context.Context, logger logging.Logger, cfg c
 	} // move to the next conversation turn
 }
 
-func (o *openAIV3Provider) createPromptMessage(ctx context.Context, logger logging.Logger, promptText string, files []config.TaskFile, result *Result) (message openai.ChatCompletionMessageParamUnion, err error) {
+func (o *openAICompletionsProvider) createPromptMessage(ctx context.Context, logger logging.Logger, promptText string, files []config.TaskFile, result *Result) (message openai.ChatCompletionMessageParamUnion, err error) {
 	if len(files) > 0 {
 		parts := make([]openai.ChatCompletionContentPartUnionParam, 0, (len(files)*2)+1)
 		for _, file := range files {
@@ -403,7 +403,7 @@ func (o *openAIV3Provider) createPromptMessage(ctx context.Context, logger loggi
 // to "high" (nearest higher) to avoid artificially reducing image fidelity during evaluations.
 // A nil or unrecognised value maps to "auto" (OpenAI's default behavior); a warning is logged
 // for unrecognised values so the operator is aware of the fallback.
-func (o *openAIV3Provider) mapImageDetailToOpenAI(ctx context.Context, logger logging.Logger, detail *config.ImageDetail) string {
+func (o *openAICompletionsProvider) mapImageDetailToOpenAI(ctx context.Context, logger logging.Logger, detail *config.ImageDetail) string {
 	if detail != nil {
 		switch *detail {
 		case config.ImageDetailAuto:
@@ -421,7 +421,7 @@ func (o *openAIV3Provider) mapImageDetailToOpenAI(ctx context.Context, logger lo
 	return "auto"
 }
 
-func (o *openAIV3Provider) isTransientResponse(err error) bool {
+func (o *openAICompletionsProvider) isTransientResponse(err error) bool {
 	return isOpenAITransientResponse(err)
 }
 
@@ -444,15 +444,15 @@ func isOpenAITransientResponse(err error) bool {
 
 // newCompletionHandler returns a fresh CompletionHandler for the current API call.
 // If a custom factory is set, it is used; otherwise, the defaultCompletionHandler is returned.
-func (o *openAIV3Provider) newCompletionHandler() CompletionHandler {
+func (o *openAICompletionsProvider) newCompletionHandler() CompletionHandler {
 	if o.NewCompletionHandler != nil {
 		return o.NewCompletionHandler()
 	}
 	return &defaultCompletionHandler{}
 }
 
 // handleRequest dispatches the request to the appropriate handler based on streaming mode.
-func (o *openAIV3Provider) handleRequest(ctx context.Context, logger logging.Logger, request openai.ChatCompletionNewParams, acc CompletionAccumulator) (*openai.ChatCompletion, error) {
+func (o *openAICompletionsProvider) handleRequest(ctx context.Context, logger logging.Logger, request openai.ChatCompletionNewParams, acc CompletionAccumulator) (*openai.ChatCompletion, error) {
 	if request.StreamOptions.IncludeUsage.Value {
 		return o.handleStreamingRequest(ctx, logger, request, acc)
 	}
@@ -461,7 +461,7 @@ func (o *openAIV3Provider) handleRequest(ctx context.Context, logger logging.Log
 
 // handleStreamingRequest executes a streaming chat completion request,
 // delegating chunk accumulation to the provided CompletionAccumulator.
-func (o *openAIV3Provider) handleStreamingRequest(ctx context.Context, logger logging.Logger, request openai.ChatCompletionNewParams, acc CompletionAccumulator) (resp *openai.ChatCompletion, err error) {
+func (o *openAICompletionsProvider) handleStreamingRequest(ctx context.Context, logger logging.Logger, request openai.ChatCompletionNewParams, acc CompletionAccumulator) (resp *openai.ChatCompletion, err error) {
 	stream := o.client.Chat.Completions.NewStreaming(ctx, request)
 	defer stream.Close()
 
@@ -476,6 +476,6 @@ func (o *openAIV3Provider) handleStreamingRequest(ctx context.Context, logger lo
 	return acc.Result(), nil
 }
 
-func (o *openAIV3Provider) Close(ctx context.Context) error {
+func (o *openAICompletionsProvider) Close(ctx context.Context) error {
 	return nil
 }

providers/openai_v3_internal_test.go …ders/openai_completions_internal_test.goproviders/openai_v3_internal_test.go renamed to providers/openai_completions_internal_test.go providers/openai_v3_internal_test.go renamed to providers/openai_completions_internal_test.go

@@ -18,9 +18,9 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestOpenAIV3_Run_IncompatibleResponseFormat(t *testing.T) {
+func TestOpenAICompletions_Run_IncompatibleResponseFormat(t *testing.T) {
 	logger := testutils.NewTestLogger(t)
-	p := &openAIV3Provider{}
+	p := &openAICompletionsProvider{}
 	runCfg := config.RunConfig{
 		Name:                    "test-run",
 		Model:                   "gpt-test",
@@ -33,9 +33,9 @@ func TestOpenAIV3_Run_IncompatibleResponseFormat(t *testing.T) {
 	require.ErrorIs(t, err, ErrIncompatibleResponseFormat)
 }
 
-func TestOpenAIV3_FileTypeNotSupported(t *testing.T) {
+func TestOpenAICompletions_FileTypeNotSupported(t *testing.T) {
 	logger := testutils.NewTestLogger(t)
-	p := &openAIV3Provider{} // nil client is sufficient to exercise early validation
+	p := &openAICompletionsProvider{} // nil client is sufficient to exercise early validation
 
 	runCfg := config.RunConfig{Name: "test-run", Model: "gpt-test"}
 	task := config.Task{
@@ -159,7 +159,7 @@ func TestDefaultCompletionHandler_ToParam(t *testing.T) {
 }
 
 func TestMapImageDetailToOpenAI(t *testing.T) {
-	provider := &openAIV3Provider{}
+	provider := &openAICompletionsProvider{}
 	logger := testutils.NewTestLogger(t)
 
 	tests := []struct {

providers/openrouter.go

@@ -35,14 +35,14 @@ func NewOpenRouter(cfg config.OpenRouterClientConfig, availableTools []config.To
 		openAIV3Opts = append(openAIV3Opts, option.WithHeader("X-Title", appTitle))
 	}
 
-	openaiProvider := newOpenAIV3Provider(availableTools, openAIV3Opts...)
+	openaiProvider := newOpenAICompletionsProvider(availableTools, openAIV3Opts...)
 
 	return &OpenRouter{openaiProvider: openaiProvider}
 }
 
 // OpenRouter implements the Provider interface for models reachable via OpenRouter.
 type OpenRouter struct {
-	openaiProvider *openAIV3Provider
+	openaiProvider *openAICompletionsProvider
 }
 
 func (o OpenRouter) Name() string {