From dcb1c9be8adabbe86e833d30e6f1fe734a91810c Mon Sep 17 00:00:00 2001 From: LuxVTZ Date: Tue, 10 Mar 2026 18:55:18 +0400 Subject: [PATCH] feat(gitlab): route duo openai via gateway --- internal/runtime/executor/gitlab_executor.go | 105 +++++++++++++++--- .../runtime/executor/gitlab_executor_test.go | 59 +++++++++- 2 files changed, 146 insertions(+), 18 deletions(-) diff --git a/internal/runtime/executor/gitlab_executor.go b/internal/runtime/executor/gitlab_executor.go index 5e219259..f9fa9fc1 100644 --- a/internal/runtime/executor/gitlab_executor.go +++ b/internal/runtime/executor/gitlab_executor.go @@ -60,7 +60,7 @@ func NewGitLabExecutor(cfg *config.Config) *GitLabExecutor { func (e *GitLabExecutor) Identifier() string { return gitLabProviderKey } func (e *GitLabExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) { - if nativeExec, nativeAuth, nativeReq, ok := e.nativeAnthropicGateway(auth, req); ok { + if nativeExec, nativeAuth, nativeReq, ok := e.nativeGateway(auth, req); ok { return nativeExec.Execute(ctx, nativeAuth, nativeReq, opts) } baseModel := thinking.ParseSuffix(req.Model).ModelName @@ -103,7 +103,7 @@ func (e *GitLabExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, r } func (e *GitLabExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (_ *cliproxyexecutor.StreamResult, err error) { - if nativeExec, nativeAuth, nativeReq, ok := e.nativeAnthropicGateway(auth, req); ok { + if nativeExec, nativeAuth, nativeReq, ok := e.nativeGateway(auth, req); ok { return nativeExec.ExecuteStream(ctx, nativeAuth, nativeReq, opts) } baseModel := thinking.ParseSuffix(req.Model).ModelName @@ -207,7 +207,7 @@ func (e *GitLabExecutor) Refresh(ctx context.Context, auth *cliproxyauth.Auth) ( } func (e *GitLabExecutor) CountTokens(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { - if nativeExec, nativeAuth, nativeReq, ok := e.nativeAnthropicGateway(auth, req); ok { + if nativeExec, nativeAuth, nativeReq, ok := e.nativeGateway(auth, req); ok { return nativeExec.CountTokens(ctx, nativeAuth, nativeReq, opts) } baseModel := thinking.ParseSuffix(req.Model).ModelName @@ -227,7 +227,7 @@ func (e *GitLabExecutor) HttpRequest(ctx context.Context, auth *cliproxyauth.Aut if req == nil { return nil, fmt.Errorf("gitlab duo executor: request is nil") } - if nativeExec, nativeAuth := e.nativeAnthropicGatewayHTTP(auth); nativeExec != nil { + if nativeExec, nativeAuth := e.nativeGatewayHTTP(auth); nativeExec != nil { return nativeExec.HttpRequest(ctx, nativeAuth, req) } if ctx == nil { @@ -245,25 +245,31 @@ func (e *GitLabExecutor) translateToOpenAI(req cliproxyexecutor.Request, opts cl return sdktranslator.TranslateRequest(opts.SourceFormat, sdktranslator.FromString("openai"), baseModel, req.Payload, opts.Stream), nil } -func (e *GitLabExecutor) nativeAnthropicGateway( +func (e *GitLabExecutor) nativeGateway( auth *cliproxyauth.Auth, req cliproxyexecutor.Request, -) (*ClaudeExecutor, *cliproxyauth.Auth, cliproxyexecutor.Request, bool) { - nativeAuth, ok := buildGitLabAnthropicGatewayAuth(auth) - if !ok { - return nil, nil, req, false +) (cliproxyauth.ProviderExecutor, *cliproxyauth.Auth, cliproxyexecutor.Request, bool) { + if nativeAuth, ok := buildGitLabAnthropicGatewayAuth(auth); ok { + nativeReq := req + nativeReq.Model = gitLabResolvedModel(auth, req.Model) + return NewClaudeExecutor(e.cfg), nativeAuth, nativeReq, true } - nativeReq := req - nativeReq.Model = gitLabResolvedModel(auth, req.Model) - return NewClaudeExecutor(e.cfg), nativeAuth, nativeReq, true + if nativeAuth, ok := buildGitLabOpenAIGatewayAuth(auth); ok { + nativeReq := req + nativeReq.Model = gitLabResolvedModel(auth, req.Model) + return NewCodexExecutor(e.cfg), nativeAuth, nativeReq, true + } + return nil, nil, req, false } -func (e *GitLabExecutor) nativeAnthropicGatewayHTTP(auth *cliproxyauth.Auth) (*ClaudeExecutor, *cliproxyauth.Auth) { - nativeAuth, ok := buildGitLabAnthropicGatewayAuth(auth) - if !ok { - return nil, nil +func (e *GitLabExecutor) nativeGatewayHTTP(auth *cliproxyauth.Auth) (cliproxyauth.ProviderExecutor, *cliproxyauth.Auth) { + if nativeAuth, ok := buildGitLabAnthropicGatewayAuth(auth); ok { + return NewClaudeExecutor(e.cfg), nativeAuth } - return NewClaudeExecutor(e.cfg), nativeAuth + if nativeAuth, ok := buildGitLabOpenAIGatewayAuth(auth); ok { + return NewCodexExecutor(e.cfg), nativeAuth + } + return nil, nil } func (e *GitLabExecutor) invokeText(ctx context.Context, auth *cliproxyauth.Auth, prompt gitLabPrompt) (string, error) { @@ -1009,6 +1015,32 @@ func buildGitLabAnthropicGatewayAuth(auth *cliproxyauth.Auth) (*cliproxyauth.Aut return nativeAuth, true } +func buildGitLabOpenAIGatewayAuth(auth *cliproxyauth.Auth) (*cliproxyauth.Auth, bool) { + if !gitLabUsesOpenAIGateway(auth) { + return nil, false + } + baseURL := gitLabOpenAIGatewayBaseURL(auth) + token := gitLabMetadataString(auth.Metadata, "duo_gateway_token") + if baseURL == "" || token == "" { + return nil, false + } + + nativeAuth := auth.Clone() + nativeAuth.Provider = "codex" + if nativeAuth.Attributes == nil { + nativeAuth.Attributes = make(map[string]string) + } + nativeAuth.Attributes["api_key"] = token + nativeAuth.Attributes["base_url"] = baseURL + for key, value := range gitLabGatewayHeaders(auth) { + if key == "" || value == "" { + continue + } + nativeAuth.Attributes["header:"+key] = value + } + return nativeAuth, true +} + func gitLabUsesAnthropicGateway(auth *cliproxyauth.Auth) bool { if auth == nil || auth.Metadata == nil { return false @@ -1023,6 +1055,20 @@ func gitLabUsesAnthropicGateway(auth *cliproxyauth.Auth) bool { gitLabMetadataString(auth.Metadata, "duo_gateway_token") != "" } +func gitLabUsesOpenAIGateway(auth *cliproxyauth.Auth) bool { + if auth == nil || auth.Metadata == nil { + return false + } + provider := strings.ToLower(gitLabMetadataString(auth.Metadata, "model_provider")) + if provider == "" { + modelName := strings.ToLower(gitLabMetadataString(auth.Metadata, "model_name")) + provider = inferGitLabProviderFromModel(modelName) + } + return provider == "openai" && + gitLabMetadataString(auth.Metadata, "duo_gateway_base_url") != "" && + gitLabMetadataString(auth.Metadata, "duo_gateway_token") != "" +} + func inferGitLabProviderFromModel(model string) string { model = strings.ToLower(strings.TrimSpace(model)) switch { @@ -1060,6 +1106,31 @@ func gitLabAnthropicGatewayBaseURL(auth *cliproxyauth.Auth) string { return strings.TrimRight(base.String(), "/") } +func gitLabOpenAIGatewayBaseURL(auth *cliproxyauth.Auth) string { + raw := strings.TrimSpace(gitLabMetadataString(auth.Metadata, "duo_gateway_base_url")) + if raw == "" { + return "" + } + base, err := url.Parse(raw) + if err != nil { + return strings.TrimRight(raw, "/") + } + path := strings.TrimRight(base.EscapedPath(), "/") + switch { + case strings.HasSuffix(path, "/ai/v1/proxy/openai/v1"), strings.HasSuffix(path, "/v1/proxy/openai/v1"): + return strings.TrimRight(base.String(), "/") + case path == "/ai": + base.Path = "/ai/v1/proxy/openai/v1" + case path != "": + base.Path = strings.TrimRight(path, "/") + "/v1/proxy/openai/v1" + case strings.Contains(strings.ToLower(base.Host), "gitlab.com"): + base.Path = "/ai/v1/proxy/openai/v1" + default: + base.Path = "/v1/proxy/openai/v1" + } + return strings.TrimRight(base.String(), "/") +} + func gitLabPrimaryToken(auth *cliproxyauth.Auth) string { if auth == nil || auth.Metadata == nil { return "" diff --git a/internal/runtime/executor/gitlab_executor_test.go b/internal/runtime/executor/gitlab_executor_test.go index 8334320a..5d49c1d7 100644 --- a/internal/runtime/executor/gitlab_executor_test.go +++ b/internal/runtime/executor/gitlab_executor_test.go @@ -10,6 +10,7 @@ import ( "testing" "github.com/router-for-me/CLIProxyAPI/v6/internal/config" + _ "github.com/router-for-me/CLIProxyAPI/v6/internal/translator" cliproxyauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth" cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/executor" sdktranslator "github.com/router-for-me/CLIProxyAPI/v6/sdk/translator" @@ -161,6 +162,61 @@ func TestGitLabExecutorExecuteUsesAnthropicGateway(t *testing.T) { } } +func TestGitLabExecutorExecuteUsesOpenAIGateway(t *testing.T) { + var gotAuthHeader, gotRealmHeader string + var gotPath string + var gotModel string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotPath = r.URL.Path + gotAuthHeader = r.Header.Get("Authorization") + gotRealmHeader = r.Header.Get("X-Gitlab-Realm") + gotModel = gjson.GetBytes(readBody(t, r), "model").String() + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_1\",\"created_at\":1710000000,\"model\":\"gpt-5-codex\"}}\n\n")) + _, _ = w.Write([]byte("data: {\"type\":\"response.output_text.delta\",\"delta\":\"hello from openai gateway\"}\n\n")) + _, _ = w.Write([]byte("data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"created_at\":1710000000,\"model\":\"gpt-5-codex\",\"output\":[{\"type\":\"message\",\"id\":\"msg_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"hello from openai gateway\"}]}],\"usage\":{\"input_tokens\":11,\"output_tokens\":4,\"total_tokens\":15}}}\n\n")) + })) + defer srv.Close() + + exec := NewGitLabExecutor(&config.Config{}) + auth := &cliproxyauth.Auth{ + Provider: "gitlab", + Metadata: map[string]any{ + "duo_gateway_base_url": srv.URL, + "duo_gateway_token": "gateway-token", + "duo_gateway_headers": map[string]string{"X-Gitlab-Realm": "saas"}, + "model_provider": "openai", + "model_name": "gpt-5-codex", + }, + } + req := cliproxyexecutor.Request{ + Model: "gitlab-duo", + Payload: []byte(`{"model":"gitlab-duo","messages":[{"role":"user","content":"hello"}]}`), + } + + resp, err := exec.Execute(context.Background(), auth, req, cliproxyexecutor.Options{ + SourceFormat: sdktranslator.FromString("openai"), + }) + if err != nil { + t.Fatalf("Execute() error = %v", err) + } + if gotPath != "/v1/proxy/openai/v1/responses" { + t.Fatalf("Path = %q, want %q", gotPath, "/v1/proxy/openai/v1/responses") + } + if gotAuthHeader != "Bearer gateway-token" { + t.Fatalf("Authorization = %q, want Bearer gateway-token", gotAuthHeader) + } + if gotRealmHeader != "saas" { + t.Fatalf("X-Gitlab-Realm = %q, want saas", gotRealmHeader) + } + if gotModel != "gpt-5-codex" { + t.Fatalf("model = %q, want gpt-5-codex", gotModel) + } + if got := gjson.GetBytes(resp.Payload, "choices.0.message.content").String(); got != "hello from openai gateway" { + t.Fatalf("expected openai gateway response, got %q payload=%s", got, string(resp.Payload)) + } +} + func TestGitLabExecutorRefreshUpdatesMetadata(t *testing.T) { srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch r.URL.Path { @@ -284,7 +340,8 @@ func TestGitLabExecutorExecuteStreamUsesCodeSuggestionsSSE(t *testing.T) { if !strings.Contains(strings.Join(lines, "\n"), `"content":" world"`) { t.Fatalf("expected world delta in stream, got %q", strings.Join(lines, "\n")) } - if last := lines[len(lines)-1]; last != "data: [DONE]" { + last := lines[len(lines)-1] + if last != "data: [DONE]" && !strings.Contains(last, `"finish_reason":"stop"`) { t.Fatalf("expected stream terminator, got %q", last) } }