Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix: support GPT-5 Responses API for OpenAI providers (#21378)

ecmadaoad6ead7eb112
diff --git a/backend/api/v1/ai_service.go b/backend/api/v1/ai_service.go
index 5a6049979c..cc3fb94fa0 100644
--- a/backend/api/v1/ai_service.go
+++ b/backend/api/v1/ai_service.go
@@ -1,22 +1,15 @@
package v1
import (
- "bytes"
"context"
- "encoding/json"
- "fmt"
- "io"
- "net/http"
- "net/url"
"connectrpc.com/connect"
- "github.com/google/uuid"
"github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
- storepb "github.com/bytebase/bytebase/backend/generated-go/store"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
"github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"
+ "github.com/bytebase/bytebase/backend/plugin/ai"
"github.com/bytebase/bytebase/backend/store"
)
@@ -28,9 +21,7 @@ type AIService struct {
// NewAIService creates a new AIService.
func NewAIService(store *store.Store) *AIService {
- return &AIService{
- store: store,
- }
+ return &AIService{store: store}
}
// Chat sends a conversation with tool definitions to the configured AI provider and returns the response.
@@ -43,707 +34,9 @@ func (s *AIService) Chat(ctx context.Context, req *connect.Request[v1pb.AIChatRe
return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("AI is not enabled"))
}
- resp, err := chatWithProvider(ctx, aiSetting, req.Msg)
+ resp, err := ai.Chat(ctx, aiSetting, req.Msg)
if err != nil {
return nil, err
}
return connect.NewResponse(resp), nil
}
-
-// chatWithProvider dispatches a chat request to the configured AI provider.
-// It is shared by the Chat RPC and backend-internal callers such as AI-powered release linting.
-func chatWithProvider(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
- switch aiSetting.Provider {
- case storepb.AISetting_OPEN_AI, storepb.AISetting_AZURE_OPENAI:
- return chatOpenAI(ctx, aiSetting, request)
- case storepb.AISetting_GEMINI:
- return chatGemini(ctx, aiSetting, request)
- case storepb.AISetting_CLAUDE:
- return chatClaude(ctx, aiSetting, request)
- default:
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupported AI provider %s", aiSetting.Provider))
- }
-}
-
-// OpenAI chat types with tool-calling support.
-
-type chatOpenAIRequest struct {
- Model string `json:"model"`
- Messages []chatOpenAIMessage `json:"messages"`
- Tools []chatOpenAITool `json:"tools,omitempty"`
-}
-
-type chatOpenAIMessage struct {
- Role string `json:"role"`
- Content *string `json:"content"`
- ToolCalls []json.RawMessage `json:"tool_calls,omitempty"`
- ToolCallID string `json:"tool_call_id,omitempty"`
-}
-
-type chatOpenAITool struct {
- Type string `json:"type"`
- Function chatOpenAIFunction `json:"function"`
-}
-
-type chatOpenAIFunction struct {
- Name string `json:"name"`
- Description string `json:"description"`
- Parameters any `json:"parameters"`
-}
-
-type chatOpenAIToolUse struct {
- ID string `json:"id"`
- Type string `json:"type"`
- Function chatOpenAIFunctionCallRef `json:"function"`
-}
-
-type chatOpenAIFunctionCallRef struct {
- Name string `json:"name"`
- Arguments string `json:"arguments"`
-}
-
-type chatOpenAIUsage struct {
- TotalTokens int32 `json:"total_tokens"`
-}
-
-type chatOpenAIResponse struct {
- Choices []struct {
- Message struct {
- Role string `json:"role"`
- Content *string `json:"content"`
- ToolCalls []json.RawMessage `json:"tool_calls"`
- } `json:"message"`
- } `json:"choices"`
- Usage *chatOpenAIUsage `json:"usage,omitempty"`
-}
-
-// chatOpenAIToolCallParsed extracts the fields we need from a raw tool call JSON.
-type chatOpenAIToolCallParsed struct {
- ID string `json:"id"`
- Function struct {
- Name string `json:"name"`
- Arguments string `json:"arguments"`
- } `json:"function"`
-}
-
-type chatToolCallMetadata struct {
- OpenAIToolCall json.RawMessage `json:"openAIToolCall,omitempty"`
- GeminiThoughtSignature string `json:"geminiThoughtSignature,omitempty"`
-}
-
-type chatOpenAIToolCallProviderFields struct {
- ExtraContent struct {
- Google struct {
- ThoughtSignature string `json:"thought_signature,omitempty"`
- } `json:"google,omitempty"`
- } `json:"extra_content,omitempty"`
-}
-
-func parseChatToolCallMetadata(raw string) (chatToolCallMetadata, bool) {
- metadataBytes := bytes.TrimSpace([]byte(raw))
- if len(metadataBytes) == 0 {
- return chatToolCallMetadata{}, false
- }
- var metadata chatToolCallMetadata
- if err := json.Unmarshal(metadataBytes, &metadata); err != nil {
- return chatToolCallMetadata{}, false
- }
- if len(metadata.OpenAIToolCall) == 0 && metadata.GeminiThoughtSignature == "" {
- return chatToolCallMetadata{}, false
- }
- return metadata, true
-}
-
-func buildChatToolCallMetadata(rawOpenAIToolCall json.RawMessage, geminiThoughtSignature string) (*string, error) {
- metadata := chatToolCallMetadata{
- OpenAIToolCall: rawOpenAIToolCall,
- GeminiThoughtSignature: geminiThoughtSignature,
- }
- if metadata.GeminiThoughtSignature == "" {
- metadata.GeminiThoughtSignature = extractGeminiThoughtSignatureFromOpenAIToolCall(rawOpenAIToolCall)
- }
- if len(metadata.OpenAIToolCall) == 0 && metadata.GeminiThoughtSignature == "" {
- return nil, nil
- }
- metadataBytes, err := json.Marshal(metadata)
- if err != nil {
- return nil, err
- }
- return new(string(metadataBytes)), nil
-}
-
-func openAIToolCallFromMetadata(raw string) json.RawMessage {
- if metadata, ok := parseChatToolCallMetadata(raw); ok {
- return metadata.OpenAIToolCall
- }
- metadataBytes := bytes.TrimSpace([]byte(raw))
- if len(metadataBytes) == 0 || !json.Valid(metadataBytes) {
- return nil
- }
- return json.RawMessage(metadataBytes)
-}
-
-func geminiThoughtSignatureFromMetadata(raw string) string {
- if metadata, ok := parseChatToolCallMetadata(raw); ok {
- if metadata.GeminiThoughtSignature != "" {
- return metadata.GeminiThoughtSignature
- }
- return extractGeminiThoughtSignatureFromOpenAIToolCall(metadata.OpenAIToolCall)
- }
- metadataBytes := bytes.TrimSpace([]byte(raw))
- if len(metadataBytes) == 0 {
- return ""
- }
- if json.Valid(metadataBytes) {
- return extractGeminiThoughtSignatureFromOpenAIToolCall(json.RawMessage(metadataBytes))
- }
- return string(metadataBytes)
-}
-
-func extractGeminiThoughtSignatureFromOpenAIToolCall(raw json.RawMessage) string {
- if len(raw) == 0 {
- return ""
- }
- var providerFields chatOpenAIToolCallProviderFields
- if err := json.Unmarshal(raw, &providerFields); err != nil {
- return ""
- }
- return providerFields.ExtraContent.Google.ThoughtSignature
-}
-
-func chatOpenAI(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
- payload := chatOpenAIRequest{
- Model: aiSetting.Model,
- }
-
- for _, m := range request.Messages {
- msg := chatOpenAIMessage{
- Role: chatMessageRoleToOpenAI(m.Role),
- }
- if m.Content != nil {
- msg.Content = m.Content
- }
- if m.ToolCallId != nil {
- msg.ToolCallID = *m.ToolCallId
- }
- for _, tc := range m.ToolCalls {
- if tc.Metadata != nil {
- if rawToolCall := openAIToolCallFromMetadata(*tc.Metadata); len(rawToolCall) > 0 {
- // Replay the raw tool call JSON exactly as received from the provider.
- // This preserves provider-specific fields like Gemini's thought_signature.
- msg.ToolCalls = append(msg.ToolCalls, rawToolCall)
- continue
- }
- }
- // Construct a standard OpenAI tool call.
- raw, _ := json.Marshal(chatOpenAIToolUse{
- ID: tc.Id,
- Type: "function",
- Function: chatOpenAIFunctionCallRef{
- Name: tc.Name,
- Arguments: tc.Arguments,
- },
- })
- msg.ToolCalls = append(msg.ToolCalls, json.RawMessage(raw))
- }
- payload.Messages = append(payload.Messages, msg)
- }
-
- for _, td := range request.ToolDefinitions {
- var params any
- if err := json.Unmarshal([]byte(td.ParametersSchema), &params); err != nil {
- return nil, errors.Errorf("failed to parse parameters schema for tool %s: %s", td.Name, err)
- }
- payload.Tools = append(payload.Tools, chatOpenAITool{
- Type: "function",
- Function: chatOpenAIFunction{
- Name: td.Name,
- Description: td.Description,
- Parameters: params,
- },
- })
- }
-
- payloadBytes, err := json.Marshal(payload)
- if err != nil {
- return nil, errors.Errorf("failed to marshal OpenAI request: %s", err)
- }
-
- httpReq, err := http.NewRequestWithContext(ctx, "POST", aiSetting.Endpoint, bytes.NewBuffer(payloadBytes))
- if err != nil {
- return nil, errors.Errorf("failed to create HTTP request: %s", err)
- }
- httpReq.Header.Set("Content-Type", "application/json")
- if aiSetting.Provider == storepb.AISetting_AZURE_OPENAI {
- httpReq.Header.Set("api-key", aiSetting.ApiKey)
- } else {
- httpReq.Header.Set("Authorization", fmt.Sprintf("Bearer %s", aiSetting.ApiKey))
- }
-
- body, err := doHTTPRequest(ctx, httpReq, "OpenAI")
- if err != nil {
- return nil, err
- }
-
- var resp chatOpenAIResponse
- if err := json.Unmarshal(body, &resp); err != nil {
- return nil, errors.Errorf("failed to unmarshal OpenAI response: %s", err)
- }
-
- result := &v1pb.AIChatResponse{}
- if resp.Usage != nil {
- result.Usage = newAIChatUsage(resp.Usage.TotalTokens)
- }
- if len(resp.Choices) > 0 {
- msg := resp.Choices[0].Message
- result.Content = msg.Content
- for _, rawTC := range msg.ToolCalls {
- var parsed chatOpenAIToolCallParsed
- if err := json.Unmarshal(rawTC, &parsed); err != nil {
- return nil, errors.Errorf("failed to parse tool call: %s", err)
- }
- // Store provider-specific tool metadata in a structured envelope so each
- // adapter can replay only the fields it understands.
- metadata, err := buildChatToolCallMetadata(rawTC, "")
- if err != nil {
- return nil, errors.Errorf("failed to encode tool call metadata: %s", err)
- }
- toolCall := &v1pb.AIChatToolCall{
- Id: parsed.ID,
- Name: parsed.Function.Name,
- Arguments: parsed.Function.Arguments,
- Metadata: metadata,
- }
- result.ToolCalls = append(result.ToolCalls, toolCall)
- }
- }
- return result, nil
-}
-
-// Claude chat types with tool-calling support.
-
-type chatClaudeRequest struct {
- Model string `json:"model"`
- System string `json:"system,omitempty"`
- Messages []chatClaudeMsg `json:"messages"`
- Tools []chatClaudeTool `json:"tools,omitempty"`
- MaxTokens int `json:"max_tokens"`
-}
-
-type chatClaudeMsg struct {
- Role string `json:"role"`
- Content any `json:"content"`
-}
-
-type chatClaudeTool struct {
- Name string `json:"name"`
- Description string `json:"description"`
- InputSchema any `json:"input_schema"`
-}
-
-type chatClaudeContentBlock struct {
- Type string `json:"type"`
- Text string `json:"text,omitempty"`
- ID string `json:"id,omitempty"`
- Name string `json:"name,omitempty"`
- Input any `json:"input,omitempty"`
- ToolUseID string `json:"tool_use_id,omitempty"`
- Content string `json:"content,omitempty"`
-}
-
-type chatClaudeUsage struct {
- InputTokens int32 `json:"input_tokens"`
- OutputTokens int32 `json:"output_tokens"`
-}
-
-type chatClaudeResponse struct {
- Content []chatClaudeContentBlock `json:"content"`
- Usage *chatClaudeUsage `json:"usage,omitempty"`
-}
-
-func chatClaude(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
- payload := chatClaudeRequest{
- Model: aiSetting.Model,
- MaxTokens: 4096,
- }
-
- for _, m := range request.Messages {
- switch m.Role {
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_SYSTEM:
- payload.System = m.GetContent()
- continue
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER:
- payload.Messages = append(payload.Messages, chatClaudeMsg{
- Role: "user",
- Content: m.GetContent(),
- })
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT:
- var contentBlocks []chatClaudeContentBlock
- if m.Content != nil && *m.Content != "" {
- contentBlocks = append(contentBlocks, chatClaudeContentBlock{
- Type: "text",
- Text: *m.Content,
- })
- }
- for _, tc := range m.ToolCalls {
- var input any
- if err := json.Unmarshal([]byte(tc.Arguments), &input); err != nil {
- input = tc.Arguments
- }
- contentBlocks = append(contentBlocks, chatClaudeContentBlock{
- Type: "tool_use",
- ID: tc.Id,
- Name: tc.Name,
- Input: input,
- })
- }
- payload.Messages = append(payload.Messages, chatClaudeMsg{
- Role: "assistant",
- Content: contentBlocks,
- })
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_TOOL:
- // Claude uses "user" role with tool_result content block.
- payload.Messages = append(payload.Messages, chatClaudeMsg{
- Role: "user",
- Content: []chatClaudeContentBlock{
- {
- Type: "tool_result",
- ToolUseID: m.GetToolCallId(),
- Content: m.GetContent(),
- },
- },
- })
- default:
- continue
- }
- }
-
- for _, td := range request.ToolDefinitions {
- var schema any
- if err := json.Unmarshal([]byte(td.ParametersSchema), &schema); err != nil {
- return nil, errors.Errorf("failed to parse parameters schema for tool %s: %s", td.Name, err)
- }
- payload.Tools = append(payload.Tools, chatClaudeTool{
- Name: td.Name,
- Description: td.Description,
- InputSchema: schema,
- })
- }
-
- payloadBytes, err := json.Marshal(payload)
- if err != nil {
- return nil, errors.Errorf("failed to marshal Claude request: %s", err)
- }
-
- httpReq, err := http.NewRequestWithContext(ctx, "POST", aiSetting.Endpoint, bytes.NewBuffer(payloadBytes))
- if err != nil {
- return nil, errors.Errorf("failed to create HTTP request: %s", err)
- }
- httpReq.Header.Set("Content-Type", "application/json")
- httpReq.Header.Set("x-api-key", aiSetting.ApiKey)
- if aiSetting.Version != "" {
- httpReq.Header.Set("anthropic-version", aiSetting.Version)
- } else {
- httpReq.Header.Set("anthropic-version", "2023-06-01")
- }
-
- body, err := doHTTPRequest(ctx, httpReq, "Claude")
- if err != nil {
- return nil, err
- }
-
- var resp chatClaudeResponse
- if err := json.Unmarshal(body, &resp); err != nil {
- return nil, errors.Errorf("failed to unmarshal Claude response: %s", err)
- }
-
- result := &v1pb.AIChatResponse{}
- if resp.Usage != nil {
- result.Usage = newAIChatUsage(resp.Usage.InputTokens + resp.Usage.OutputTokens)
- }
- var textContent string
- for _, block := range resp.Content {
- switch block.Type {
- case "text":
- textContent += block.Text
- case "tool_use":
- args, err := json.Marshal(block.Input)
- if err != nil {
- return nil, errors.Errorf("failed to marshal tool call input: %s", err)
- }
- result.ToolCalls = append(result.ToolCalls, &v1pb.AIChatToolCall{
- Id: block.ID,
- Name: block.Name,
- Arguments: string(args),
- })
- default:
- }
- }
- if textContent != "" {
- result.Content = &textContent
- }
- return result, nil
-}
-
-// Gemini chat types with tool-calling support.
-
-type chatGeminiRequest struct {
- Contents []chatGeminiContent `json:"contents"`
- Tools []chatGeminiTool `json:"tools,omitempty"`
-}
-
-type chatGeminiContent struct {
- Role string `json:"role"`
- Parts []chatGeminiPart `json:"parts"`
-}
-
-type chatGeminiPart struct {
- Text string `json:"text,omitempty"`
- FunctionCall *chatGeminiFunctionCall `json:"functionCall,omitempty"`
- FunctionResponse *chatGeminiFunctionResult `json:"functionResponse,omitempty"`
- ThoughtSignature string `json:"thoughtSignature,omitempty"`
-}
-
-type chatGeminiFunctionCall struct {
- Name string `json:"name"`
- Args any `json:"args"`
-}
-
-type chatGeminiFunctionResult struct {
- Name string `json:"name"`
- Response any `json:"response"`
-}
-
-type chatGeminiTool struct {
- FunctionDeclarations []chatGeminiFunctionDecl `json:"functionDeclarations"`
-}
-
-type chatGeminiFunctionDecl struct {
- Name string `json:"name"`
- Description string `json:"description"`
- Parameters any `json:"parameters"`
-}
-
-type chatGeminiUsage struct {
- TotalTokenCount int32 `json:"totalTokenCount"`
-}
-
-type chatGeminiResponse struct {
- Candidates []struct {
- Content struct {
- Parts []chatGeminiResponsePart `json:"parts"`
- } `json:"content"`
- } `json:"candidates"`
- UsageMetadata *chatGeminiUsage `json:"usageMetadata,omitempty"`
-}
-
-type chatGeminiResponsePart struct {
- Text string `json:"text,omitempty"`
- FunctionCall *chatGeminiFunctionCall `json:"functionCall,omitempty"`
- ThoughtSignature string `json:"thoughtSignature,omitempty"`
-}
-
-func newGeminiToolCallID(name string) string {
- return fmt.Sprintf("call_%s_%s", name, uuid.NewString())
-}
-
-func chatGemini(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
- payload := chatGeminiRequest{}
-
- for _, m := range request.Messages {
- switch m.Role {
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_SYSTEM:
- // Gemini handles system messages as the first user message.
- payload.Contents = append(payload.Contents, chatGeminiContent{
- Role: "user",
- Parts: []chatGeminiPart{{Text: m.GetContent()}},
- })
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER:
- payload.Contents = append(payload.Contents, chatGeminiContent{
- Role: "user",
- Parts: []chatGeminiPart{{Text: m.GetContent()}},
- })
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT:
- var parts []chatGeminiPart
- if m.Content != nil && *m.Content != "" {
- parts = append(parts, chatGeminiPart{Text: *m.Content})
- }
- for _, tc := range m.ToolCalls {
- var args any
- if err := json.Unmarshal([]byte(tc.Arguments), &args); err != nil {
- args = tc.Arguments
- }
- part := chatGeminiPart{
- FunctionCall: &chatGeminiFunctionCall{
- Name: tc.Name,
- Args: args,
- },
- }
- if tc.Metadata != nil {
- part.ThoughtSignature = geminiThoughtSignatureFromMetadata(*tc.Metadata)
- }
- parts = append(parts, part)
- }
- payload.Contents = append(payload.Contents, chatGeminiContent{
- Role: "model",
- Parts: parts,
- })
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_TOOL:
- // Gemini uses functionResponse parts in a "user" role message.
- // We need the tool name; get it from the tool call ID by searching prior messages.
- toolName := getToolNameFromMessages(request.Messages, m.GetToolCallId())
- var resultData any
- if err := json.Unmarshal([]byte(m.GetContent()), &resultData); err != nil {
- resultData = map[string]string{"result": m.GetContent()}
- }
- payload.Contents = append(payload.Contents, chatGeminiContent{
- Role: "user",
- Parts: []chatGeminiPart{
- {
- FunctionResponse: &chatGeminiFunctionResult{
- Name: toolName,
- Response: resultData,
- },
- },
- },
- })
- default:
- }
- }
-
- if len(request.ToolDefinitions) > 0 {
- var decls []chatGeminiFunctionDecl
- for _, td := range request.ToolDefinitions {
- var params any
- if err := json.Unmarshal([]byte(td.ParametersSchema), &params); err != nil {
- return nil, errors.Errorf("failed to parse parameters schema for tool %s: %s", td.Name, err)
- }
- decls = append(decls, chatGeminiFunctionDecl{
- Name: td.Name,
- Description: td.Description,
- Parameters: params,
- })
- }
- payload.Tools = []chatGeminiTool{{FunctionDeclarations: decls}}
- }
-
- payloadBytes, err := json.Marshal(payload)
- if err != nil {
- return nil, errors.Errorf("failed to marshal Gemini request: %s", err)
- }
-
- requestURL, err := url.JoinPath(aiSetting.Endpoint, "models", aiSetting.Model+":generateContent")
- if err != nil {
- return nil, errors.Wrap(err, "failed to build Gemini request URL")
- }
- httpReq, err := http.NewRequestWithContext(ctx, "POST", requestURL, bytes.NewBuffer(payloadBytes))
- if err != nil {
- return nil, errors.Errorf("failed to create HTTP request: %s", err)
- }
- httpReq.Header.Set("Content-Type", "application/json")
- httpReq.Header.Set("x-goog-api-key", aiSetting.ApiKey)
-
- body, err := doHTTPRequest(ctx, httpReq, "Gemini")
- if err != nil {
- return nil, err
- }
-
- var resp chatGeminiResponse
- if err := json.Unmarshal(body, &resp); err != nil {
- return nil, errors.Errorf("failed to unmarshal Gemini response: %s", err)
- }
-
- result := &v1pb.AIChatResponse{}
- if resp.UsageMetadata != nil {
- result.Usage = newAIChatUsage(resp.UsageMetadata.TotalTokenCount)
- }
- if len(resp.Candidates) > 0 {
- var textContent string
- for _, part := range resp.Candidates[0].Content.Parts {
- if part.Text != "" {
- textContent += part.Text
- }
- if part.FunctionCall != nil {
- args, err := json.Marshal(part.FunctionCall.Args)
- if err != nil {
- return nil, errors.Errorf("failed to marshal function call args: %s", err)
- }
- tc := &v1pb.AIChatToolCall{
- Id: newGeminiToolCallID(part.FunctionCall.Name),
- Name: part.FunctionCall.Name,
- Arguments: string(args),
- }
- if part.ThoughtSignature != "" {
- metadata, err := buildChatToolCallMetadata(nil, part.ThoughtSignature)
- if err != nil {
- return nil, errors.Errorf("failed to encode Gemini tool metadata: %s", err)
- }
- tc.Metadata = metadata
- }
- result.ToolCalls = append(result.ToolCalls, tc)
- }
- }
- if textContent != "" {
- result.Content = &textContent
- }
- }
- return result, nil
-}
-
-func newAIChatUsage(totalTokens int32) *v1pb.AIChatUsage {
- if totalTokens <= 0 {
- return nil
- }
- return &v1pb.AIChatUsage{
- TotalTokens: totalTokens,
- }
-}
-
-// doHTTPRequest executes an HTTP request and returns the response body.
-func doHTTPRequest(_ context.Context, httpReq *http.Request, provider string) ([]byte, error) {
- client := &http.Client{}
- httpResp, err := client.Do(httpReq)
- if err != nil {
- return nil, errors.Errorf("failed to send HTTP request to %s: %s", provider, err)
- }
- defer httpResp.Body.Close()
-
- body, err := io.ReadAll(httpResp.Body)
- if err != nil {
- return nil, errors.Errorf("failed to read %s response body: %s", provider, err)
- }
-
- if httpResp.StatusCode != http.StatusOK {
- return nil, errors.Errorf("%s API returned status %d: %s", provider, httpResp.StatusCode, string(body))
- }
-
- return body, nil
-}
-
-// chatMessageRoleToOpenAI converts a proto role enum to OpenAI role string.
-func chatMessageRoleToOpenAI(role v1pb.AIChatMessageRole) string {
- switch role {
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_SYSTEM:
- return "system"
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER:
- return "user"
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT:
- return "assistant"
- case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_TOOL:
- return "tool"
- default:
- return "user"
- }
-}
-
-// getToolNameFromMessages finds the tool name for a given tool call ID by searching assistant messages.
-func getToolNameFromMessages(messages []*v1pb.AIChatMessage, toolCallID string) string {
- for _, m := range messages {
- for _, tc := range m.ToolCalls {
- if tc.Id == toolCallID {
- return tc.Name
- }
- }
- }
- return toolCallID
-}
diff --git a/backend/api/v1/ai_service_test.go b/backend/api/v1/ai_service_test.go
deleted file mode 100644
index 25f289a4b2..0000000000
--- a/backend/api/v1/ai_service_test.go
+++ /dev/null
@@ -1,174 +0,0 @@
-package v1
-
-import (
- "context"
- "encoding/json"
- "net/http"
- "net/http/httptest"
- "testing"
-
- "github.com/stretchr/testify/require"
-
- storepb "github.com/bytebase/bytebase/backend/generated-go/store"
- v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
-)
-
-func TestChatGeminiPartMarshalsThoughtSignatureOnPart(t *testing.T) {
- t.Parallel()
-
- payload := chatGeminiRequest{
- Contents: []chatGeminiContent{{
- Role: "model",
- Parts: []chatGeminiPart{{
- FunctionCall: &chatGeminiFunctionCall{
- Name: "list_tables",
- Args: map[string]any{"database": "db"},
- },
- ThoughtSignature: "sig-123",
- }},
- }},
- }
-
- payloadBytes, err := json.Marshal(payload)
- require.NoError(t, err)
-
- var raw map[string]any
- require.NoError(t, json.Unmarshal(payloadBytes, &raw))
-
- contents, ok := raw["contents"].([]any)
- require.True(t, ok)
- require.Len(t, contents, 1)
-
- content, ok := contents[0].(map[string]any)
- require.True(t, ok)
-
- parts, ok := content["parts"].([]any)
- require.True(t, ok)
- require.Len(t, parts, 1)
-
- part, ok := parts[0].(map[string]any)
- require.True(t, ok)
- require.Equal(t, "sig-123", part["thoughtSignature"])
-
- functionCall, ok := part["functionCall"].(map[string]any)
- require.True(t, ok)
- require.Equal(t, "list_tables", functionCall["name"])
- require.NotContains(t, functionCall, "thoughtSignature")
-}
-
-func TestChatGeminiResponsePartUnmarshalsThoughtSignatureFromPart(t *testing.T) {
- t.Parallel()
-
- var part chatGeminiResponsePart
- err := json.Unmarshal([]byte(`{
- "functionCall": {
- "name": "list_tables",
- "args": {"database": "db"}
- },
- "thoughtSignature": "sig-123"
- }`), &part)
- require.NoError(t, err)
- require.NotNil(t, part.FunctionCall)
- require.Equal(t, "list_tables", part.FunctionCall.Name)
- require.Equal(t, "sig-123", part.ThoughtSignature)
-}
-
-func TestBuildChatToolCallMetadataExtractsGeminiThoughtSignature(t *testing.T) {
- t.Parallel()
-
- rawToolCall := json.RawMessage(`{
- "id": "call-1",
- "type": "function",
- "function": {
- "name": "get_page_state",
- "arguments": "{}"
- },
- "extra_content": {
- "google": {
- "thought_signature": "sig-123"
- }
- }
- }`)
-
- metadata, err := buildChatToolCallMetadata(rawToolCall, "")
- require.NoError(t, err)
- require.NotNil(t, metadata)
- require.Equal(t, "sig-123", geminiThoughtSignatureFromMetadata(*metadata))
- require.JSONEq(t, string(rawToolCall), string(openAIToolCallFromMetadata(*metadata)))
-}
-
-func TestGeminiThoughtSignatureFromMetadataSupportsLegacyFormats(t *testing.T) {
- t.Parallel()
-
- t.Run("legacy raw tool call with thought signature", func(t *testing.T) {
- t.Parallel()
-
- metadata := `{
- "id": "call-1",
- "type": "function",
- "function": {
- "name": "get_page_state",
- "arguments": "{}"
- },
- "extra_content": {
- "google": {
- "thought_signature": "sig-legacy"
- }
- }
- }`
- require.Equal(t, "sig-legacy", geminiThoughtSignatureFromMetadata(metadata))
- })
-
- t.Run("legacy raw tool call without thought signature", func(t *testing.T) {
- t.Parallel()
-
- metadata := `{
- "id": "call-2",
- "type": "function",
- "function": {
- "name": "search_api",
- "arguments": "{}"
- }
- }`
- require.Empty(t, geminiThoughtSignatureFromMetadata(metadata))
- })
-
- t.Run("native Gemini thought signature string", func(t *testing.T) {
- t.Parallel()
-
- require.Equal(t, "sig-native", geminiThoughtSignatureFromMetadata("sig-native"))
- })
-}
-
-func TestChatGeminiGeneratesUniqueToolCallIDs(t *testing.T) {
- t.Parallel()
-
- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
- w.Header().Set("Content-Type", "application/json")
- _, err := w.Write([]byte(`{
- "candidates": [{
- "content": {
- "parts": [
- {"functionCall": {"name": "search_api", "args": {"service": "SQLService"}}},
- {"functionCall": {"name": "search_api", "args": {"operationId": "SQLService/Query"}}}
- ]
- }
- }]
- }`))
- require.NoError(t, err)
- }))
- defer server.Close()
-
- resp, err := chatGemini(
- context.Background(),
- &storepb.AISetting{
- Endpoint: server.URL,
- Model: "gemini-2.5-pro",
- ApiKey: "test-key",
- },
- &v1pb.AIChatRequest{},
- )
- require.NoError(t, err)
- require.Len(t, resp.ToolCalls, 2)
- require.NotEqual(t, resp.ToolCalls[0].Id, resp.ToolCalls[1].Id)
-}
diff --git a/backend/api/v1/release_service_ai_lint.go b/backend/api/v1/release_service_ai_lint.go
index beb8a69b15..3dedbc3433 100644
--- a/backend/api/v1/release_service_ai_lint.go
+++ b/backend/api/v1/release_service_ai_lint.go
@@ -11,6 +11,7 @@ import (
"github.com/bytebase/bytebase/backend/common"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+ "github.com/bytebase/bytebase/backend/plugin/ai"
)
// aiLintResult represents a single lint result from AI.
@@ -64,7 +65,7 @@ func (s *ReleaseService) runAIPoweredLintBatch(ctx context.Context, files []file
}
slog.Info("Calling AI provider for batch schema linting", "provider", aiSetting.Provider, "endpoint", aiSetting.Endpoint, "filesCount", len(files))
- resp, err := chatWithProvider(ctx, aiSetting, request)
+ resp, err := ai.Chat(ctx, aiSetting, request)
if err != nil {
slog.Error("AI call failed", "provider", aiSetting.Provider, "error", err)
return nil, errors.Wrapf(err, "%s API call failed", aiSetting.Provider)
diff --git a/backend/plugin/ai/ai.go b/backend/plugin/ai/ai.go
new file mode 100644
index 0000000000..047f46b678
--- /dev/null
+++ b/backend/plugin/ai/ai.go
@@ -0,0 +1,26 @@
+// Package ai provides adapters for configured AI providers.
+package ai
+
+import (
+ "context"
+
+ "connectrpc.com/connect"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+)
+
+// Chat sends a chat request to the configured AI provider.
+func Chat(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
+ switch aiSetting.Provider {
+ case storepb.AISetting_OPEN_AI, storepb.AISetting_AZURE_OPENAI:
+ return chatOpenAI(ctx, aiSetting, request)
+ case storepb.AISetting_GEMINI:
+ return chatGemini(ctx, aiSetting, request)
+ case storepb.AISetting_CLAUDE:
+ return chatClaude(ctx, aiSetting, request)
+ default:
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupported AI provider %s", aiSetting.Provider))
+ }
+}
diff --git a/backend/plugin/ai/ai_test.go b/backend/plugin/ai/ai_test.go
new file mode 100644
index 0000000000..4633499bc2
--- /dev/null
+++ b/backend/plugin/ai/ai_test.go
@@ -0,0 +1,495 @@
+package ai
+
+import (
+ "context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+)
+
+func TestChatGeminiPartMarshalsThoughtSignatureOnPart(t *testing.T) {
+ t.Parallel()
+
+ payload := chatGeminiRequest{
+ Contents: []chatGeminiContent{{
+ Role: "model",
+ Parts: []chatGeminiPart{{
+ FunctionCall: &chatGeminiFunctionCall{
+ Name: "list_tables",
+ Args: map[string]any{"database": "db"},
+ },
+ ThoughtSignature: "sig-123",
+ }},
+ }},
+ }
+
+ payloadBytes, err := json.Marshal(payload)
+ require.NoError(t, err)
+
+ var raw map[string]any
+ require.NoError(t, json.Unmarshal(payloadBytes, &raw))
+
+ contents, ok := raw["contents"].([]any)
+ require.True(t, ok)
+ require.Len(t, contents, 1)
+
+ content, ok := contents[0].(map[string]any)
+ require.True(t, ok)
+
+ parts, ok := content["parts"].([]any)
+ require.True(t, ok)
+ require.Len(t, parts, 1)
+
+ part, ok := parts[0].(map[string]any)
+ require.True(t, ok)
+ require.Equal(t, "sig-123", part["thoughtSignature"])
+
+ functionCall, ok := part["functionCall"].(map[string]any)
+ require.True(t, ok)
+ require.Equal(t, "list_tables", functionCall["name"])
+ require.NotContains(t, functionCall, "thoughtSignature")
+}
+
+func TestChatGeminiResponsePartUnmarshalsThoughtSignatureFromPart(t *testing.T) {
+ t.Parallel()
+
+ var part chatGeminiResponsePart
+ err := json.Unmarshal([]byte(`{
+ "functionCall": {
+ "name": "list_tables",
+ "args": {"database": "db"}
+ },
+ "thoughtSignature": "sig-123"
+ }`), &part)
+ require.NoError(t, err)
+ require.NotNil(t, part.FunctionCall)
+ require.Equal(t, "list_tables", part.FunctionCall.Name)
+ require.Equal(t, "sig-123", part.ThoughtSignature)
+}
+
+func TestBuildChatToolCallMetadataExtractsGeminiThoughtSignature(t *testing.T) {
+ t.Parallel()
+
+ rawToolCall := json.RawMessage(`{
+ "id": "call-1",
+ "type": "function",
+ "function": {
+ "name": "get_page_state",
+ "arguments": "{}"
+ },
+ "extra_content": {
+ "google": {
+ "thought_signature": "sig-123"
+ }
+ }
+ }`)
+
+ metadata, err := buildChatToolCallMetadata(rawToolCall, "")
+ require.NoError(t, err)
+ require.NotNil(t, metadata)
+ require.Equal(t, "sig-123", geminiThoughtSignatureFromMetadata(*metadata))
+ require.JSONEq(t, string(rawToolCall), string(openAIToolCallFromMetadata(*metadata)))
+}
+
+func TestGeminiThoughtSignatureFromMetadataSupportsLegacyFormats(t *testing.T) {
+ t.Parallel()
+
+ t.Run("legacy raw tool call with thought signature", func(t *testing.T) {
+ t.Parallel()
+
+ metadata := `{
+ "id": "call-1",
+ "type": "function",
+ "function": {
+ "name": "get_page_state",
+ "arguments": "{}"
+ },
+ "extra_content": {
+ "google": {
+ "thought_signature": "sig-legacy"
+ }
+ }
+ }`
+ require.Equal(t, "sig-legacy", geminiThoughtSignatureFromMetadata(metadata))
+ })
+
+ t.Run("legacy raw tool call without thought signature", func(t *testing.T) {
+ t.Parallel()
+
+ metadata := `{
+ "id": "call-2",
+ "type": "function",
+ "function": {
+ "name": "search_api",
+ "arguments": "{}"
+ }
+ }`
+ require.Empty(t, geminiThoughtSignatureFromMetadata(metadata))
+ })
+
+ t.Run("native Gemini thought signature string", func(t *testing.T) {
+ t.Parallel()
+
+ require.Equal(t, "sig-native", geminiThoughtSignatureFromMetadata("sig-native"))
+ })
+}
+
+func TestChatGeminiGeneratesUniqueToolCallIDs(t *testing.T) {
+ t.Parallel()
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ _, err := w.Write([]byte(`{
+ "candidates": [{
+ "content": {
+ "parts": [
+ {"functionCall": {"name": "search_api", "args": {"service": "SQLService"}}},
+ {"functionCall": {"name": "search_api", "args": {"operationId": "SQLService/Query"}}}
+ ]
+ }
+ }]
+ }`))
+ require.NoError(t, err)
+ }))
+ defer server.Close()
+
+ resp, err := chatGemini(
+ context.Background(),
+ &storepb.AISetting{
+ Endpoint: server.URL,
+ Model: "gemini-2.5-pro",
+ ApiKey: "test-key",
+ },
+ &v1pb.AIChatRequest{},
+ )
+ require.NoError(t, err)
+ require.Len(t, resp.ToolCalls, 2)
+ require.NotEqual(t, resp.ToolCalls[0].Id, resp.ToolCalls[1].Id)
+}
+
+func TestChatOpenAIResponsesEndpointUsesResponsesWireFormat(t *testing.T) {
+ t.Parallel()
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ require.Equal(t, http.MethodPost, r.Method)
+ require.Equal(t, "test-key", r.Header.Get("api-key"))
+ require.Empty(t, r.Header.Get("Authorization"))
+
+ var payload map[string]any
+ require.NoError(t, json.NewDecoder(r.Body).Decode(&payload))
+ require.Equal(t, "deployment", payload["model"])
+ require.Equal(t, false, payload["store"])
+ require.Equal(t, []any{"reasoning.encrypted_content"}, payload["include"])
+ require.NotContains(t, payload, "messages")
+ require.Contains(t, payload, "input")
+ tools, ok := payload["tools"].([]any)
+ require.True(t, ok)
+ require.Equal(t, map[string]any{
+ "type": "function",
+ "name": "list_tables",
+ "description": "Lists tables",
+ "parameters": map[string]any{"type": "object"},
+ }, tools[0])
+
+ _, err := w.Write([]byte(`{
+ "output": [{"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "hello"}]}],
+ "usage": {"total_tokens": 3}
+ }`))
+ require.NoError(t, err)
+ }))
+ defer server.Close()
+
+ content := "Find tables"
+ resp, err := chatOpenAI(
+ context.Background(),
+ &storepb.AISetting{
+ Provider: storepb.AISetting_AZURE_OPENAI,
+ Endpoint: server.URL + "/openai/v1/responses",
+ Model: "deployment",
+ ApiKey: "test-key",
+ },
+ &v1pb.AIChatRequest{
+ Messages: []*v1pb.AIChatMessage{{
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER,
+ Content: &content,
+ }},
+ ToolDefinitions: []*v1pb.AIChatToolDefinition{{
+ Name: "list_tables",
+ Description: "Lists tables",
+ ParametersSchema: `{"type":"object"}`,
+ }},
+ },
+ )
+ require.NoError(t, err)
+ require.Equal(t, "hello", resp.GetContent())
+ require.EqualValues(t, 3, resp.GetUsage().GetTotalTokens())
+}
+
+func TestChatOpenAIResponsesReplaysOutputForToolResult(t *testing.T) {
+ t.Parallel()
+
+ requestCount := 0
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ requestCount++
+ var payload map[string]any
+ require.NoError(t, json.NewDecoder(r.Body).Decode(&payload))
+ input, ok := payload["input"].([]any)
+ require.True(t, ok)
+
+ switch requestCount {
+ case 1:
+ _, err := w.Write([]byte(`{
+ "output": [
+ {"type": "reasoning", "id": "rs_1", "encrypted_content": "ciphertext"},
+ {"type": "function_call", "call_id": "call_1", "name": "list_tables", "arguments": "{}"}
+ ]
+ }`))
+ require.NoError(t, err)
+ case 2:
+ require.Contains(t, input, map[string]any{
+ "type": "reasoning",
+ "id": "rs_1",
+ "encrypted_content": "ciphertext",
+ })
+ require.Contains(t, input, map[string]any{
+ "type": "function_call",
+ "call_id": "call_1",
+ "name": "list_tables",
+ "arguments": "{}",
+ })
+ require.Contains(t, input, map[string]any{
+ "type": "function_call_output",
+ "call_id": "call_1",
+ "output": "users, projects",
+ })
+ _, err := w.Write([]byte(`{"output": []}`))
+ require.NoError(t, err)
+ default:
+ t.Fatalf("unexpected request %d", requestCount)
+ }
+ }))
+ defer server.Close()
+
+ userContent := "Find tables"
+ setting := &storepb.AISetting{
+ Endpoint: server.URL + "/responses",
+ Model: "deployment",
+ ApiKey: "test-key",
+ }
+ first, err := chatOpenAI(context.Background(), setting, &v1pb.AIChatRequest{
+ Messages: []*v1pb.AIChatMessage{{
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER,
+ Content: &userContent,
+ }},
+ })
+ require.NoError(t, err)
+ require.Len(t, first.ToolCalls, 1)
+
+ toolResult := "users, projects"
+ _, err = chatOpenAI(context.Background(), setting, &v1pb.AIChatRequest{
+ Messages: []*v1pb.AIChatMessage{
+ {
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER,
+ Content: &userContent,
+ },
+ {
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT,
+ ToolCalls: first.ToolCalls,
+ },
+ {
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_TOOL,
+ Content: &toolResult,
+ ToolCallId: &first.ToolCalls[0].Id,
+ },
+ },
+ })
+ require.NoError(t, err)
+ require.Equal(t, 2, requestCount)
+}
+
+func TestChatClaudeReplaysThinkingBlocksForToolResult(t *testing.T) {
+ t.Parallel()
+
+ requestCount := 0
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ requestCount++
+ var payload map[string]any
+ require.NoError(t, json.NewDecoder(r.Body).Decode(&payload))
+
+ switch requestCount {
+ case 1:
+ _, err := w.Write([]byte(`{
+ "content": [
+ {"type": "thinking", "thinking": "", "signature": "sig_1"},
+ {"type": "text", "text": "I will check the tables."},
+ {"type": "tool_use", "id": "toolu_1", "name": "list_tables", "input": {}}
+ ]
+ }`))
+ require.NoError(t, err)
+ case 2:
+ messages, ok := payload["messages"].([]any)
+ require.True(t, ok)
+ require.Contains(t, messages, map[string]any{
+ "role": "assistant",
+ "content": []any{
+ map[string]any{"type": "thinking", "thinking": "", "signature": "sig_1"},
+ map[string]any{"type": "text", "text": "I will check the tables."},
+ map[string]any{"type": "tool_use", "id": "toolu_1", "name": "list_tables", "input": map[string]any{}},
+ },
+ })
+ _, err := w.Write([]byte(`{"content": []}`))
+ require.NoError(t, err)
+ default:
+ t.Fatalf("unexpected request %d", requestCount)
+ }
+ }))
+ defer server.Close()
+
+ userContent := "Find tables"
+ setting := &storepb.AISetting{
+ Endpoint: server.URL,
+ Model: "claude-sonnet-5",
+ ApiKey: "test-key",
+ }
+ first, err := chatClaude(context.Background(), setting, &v1pb.AIChatRequest{
+ Messages: []*v1pb.AIChatMessage{{
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER,
+ Content: &userContent,
+ }},
+ })
+ require.NoError(t, err)
+ require.Len(t, first.ToolCalls, 1)
+ require.NotNil(t, first.ToolCalls[0].Metadata)
+ require.Equal(t, "I will check the tables.", first.GetContent())
+
+ toolResult := "users, projects"
+ _, err = chatClaude(context.Background(), setting, &v1pb.AIChatRequest{
+ Messages: []*v1pb.AIChatMessage{
+ {
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER,
+ Content: &userContent,
+ },
+ {
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT,
+ ToolCalls: first.ToolCalls,
+ },
+ {
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_TOOL,
+ Content: &toolResult,
+ ToolCallId: &first.ToolCalls[0].Id,
+ },
+ },
+ })
+ require.NoError(t, err)
+ require.Equal(t, 2, requestCount)
+}
+
+func TestChatOpenAIChatCompletionsEndpointUsesChatCompletions(t *testing.T) {
+ t.Parallel()
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ var payload map[string]any
+ require.NoError(t, json.NewDecoder(r.Body).Decode(&payload))
+ require.Contains(t, payload, "messages")
+ require.NotContains(t, payload, "input")
+ _, err := w.Write([]byte(`{
+ "choices": [{"message": {"role": "assistant", "content": "hello"}}]
+ }`))
+ require.NoError(t, err)
+ }))
+ defer server.Close()
+
+ content := "Hello"
+ resp, err := chatOpenAI(context.Background(), &storepb.AISetting{
+ Endpoint: server.URL + "/chat/completions",
+ Model: "gpt-5.5",
+ ApiKey: "test-key",
+ }, &v1pb.AIChatRequest{
+ Messages: []*v1pb.AIChatMessage{{
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER,
+ Content: &content,
+ }},
+ })
+ require.NoError(t, err)
+ require.Equal(t, "hello", resp.GetContent())
+}
+
+func TestChatOpenAIResponsesFormatsAssistantHistoryAsOutputMessage(t *testing.T) {
+ t.Parallel()
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ var payload map[string]any
+ require.NoError(t, json.NewDecoder(r.Body).Decode(&payload))
+ input, ok := payload["input"].([]any)
+ require.True(t, ok)
+ require.Contains(t, input, map[string]any{
+ "type": "message",
+ "role": "assistant",
+ "status": "completed",
+ "content": []any{map[string]any{
+ "type": "output_text",
+ "text": "Previous answer",
+ }},
+ })
+ _, err := w.Write([]byte(`{"output": []}`))
+ require.NoError(t, err)
+ }))
+ defer server.Close()
+
+ userContent := "Follow up"
+ assistantContent := "Previous answer"
+ _, err := chatOpenAI(context.Background(), &storepb.AISetting{
+ Endpoint: server.URL + "/responses",
+ Model: "deployment",
+ }, &v1pb.AIChatRequest{
+ Messages: []*v1pb.AIChatMessage{
+ {
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER,
+ Content: &userContent,
+ },
+ {
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT,
+ Content: &assistantContent,
+ },
+ },
+ })
+ require.NoError(t, err)
+}
+
+func TestChatOpenAIResponsesSurfacesRefusalContent(t *testing.T) {
+ t.Parallel()
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ _, err := w.Write([]byte(`{
+ "output": [{
+ "type": "message",
+ "role": "assistant",
+ "content": [{
+ "type": "refusal",
+ "refusal": "I can't help with that request."
+ }]
+ }]
+ }`))
+ require.NoError(t, err)
+ }))
+ defer server.Close()
+
+ content := "Unsafe request"
+ resp, err := chatOpenAI(context.Background(), &storepb.AISetting{
+ Endpoint: server.URL + "/responses",
+ Model: "gpt-5.6-terra",
+ }, &v1pb.AIChatRequest{
+ Messages: []*v1pb.AIChatMessage{{
+ Role: v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER,
+ Content: &content,
+ }},
+ })
+ require.NoError(t, err)
+ require.Equal(t, "I can't help with that request.", resp.GetContent())
+}
diff --git a/backend/plugin/ai/claude.go b/backend/plugin/ai/claude.go
new file mode 100644
index 0000000000..e6afa242b9
--- /dev/null
+++ b/backend/plugin/ai/claude.go
@@ -0,0 +1,210 @@
+package ai
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "net/http"
+
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+)
+
+// Claude chat types with tool-calling support.
+
+type chatClaudeRequest struct {
+ Model string `json:"model"`
+ System string `json:"system,omitempty"`
+ Messages []chatClaudeMsg `json:"messages"`
+ Tools []chatClaudeTool `json:"tools,omitempty"`
+ MaxTokens int `json:"max_tokens"`
+}
+
+type chatClaudeMsg struct {
+ Role string `json:"role"`
+ Content any `json:"content"`
+}
+
+type chatClaudeTool struct {
+ Name string `json:"name"`
+ Description string `json:"description"`
+ InputSchema any `json:"input_schema"`
+}
+
+type chatClaudeContentBlock struct {
+ Type string `json:"type"`
+ Text string `json:"text,omitempty"`
+ ID string `json:"id,omitempty"`
+ Name string `json:"name,omitempty"`
+ Input any `json:"input,omitempty"`
+ ToolUseID string `json:"tool_use_id,omitempty"`
+ Content string `json:"content,omitempty"`
+}
+
+type chatClaudeUsage struct {
+ InputTokens int32 `json:"input_tokens"`
+ OutputTokens int32 `json:"output_tokens"`
+}
+
+type chatClaudeResponse struct {
+ Content []json.RawMessage `json:"content"`
+ Usage *chatClaudeUsage `json:"usage,omitempty"`
+}
+
+func claudeContentFromToolCalls(toolCalls []*v1pb.AIChatToolCall) []json.RawMessage {
+ for _, toolCall := range toolCalls {
+ if toolCall.Metadata == nil {
+ continue
+ }
+ if content := claudeContentFromMetadata(*toolCall.Metadata); len(content) > 0 {
+ return content
+ }
+ }
+ return nil
+}
+
+func chatClaude(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
+ payload := chatClaudeRequest{
+ Model: aiSetting.Model,
+ MaxTokens: 4096,
+ }
+
+ for _, m := range request.Messages {
+ switch m.Role {
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_SYSTEM:
+ payload.System = m.GetContent()
+ continue
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER:
+ payload.Messages = append(payload.Messages, chatClaudeMsg{
+ Role: "user",
+ Content: m.GetContent(),
+ })
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT:
+ if content := claudeContentFromToolCalls(m.ToolCalls); len(content) > 0 {
+ payload.Messages = append(payload.Messages, chatClaudeMsg{
+ Role: "assistant",
+ Content: content,
+ })
+ continue
+ }
+ var contentBlocks []chatClaudeContentBlock
+ if m.Content != nil && *m.Content != "" {
+ contentBlocks = append(contentBlocks, chatClaudeContentBlock{
+ Type: "text",
+ Text: *m.Content,
+ })
+ }
+ for _, tc := range m.ToolCalls {
+ var input any
+ if err := json.Unmarshal([]byte(tc.Arguments), &input); err != nil {
+ input = tc.Arguments
+ }
+ contentBlocks = append(contentBlocks, chatClaudeContentBlock{
+ Type: "tool_use",
+ ID: tc.Id,
+ Name: tc.Name,
+ Input: input,
+ })
+ }
+ payload.Messages = append(payload.Messages, chatClaudeMsg{
+ Role: "assistant",
+ Content: contentBlocks,
+ })
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_TOOL:
+ // Claude uses "user" role with tool_result content block.
+ payload.Messages = append(payload.Messages, chatClaudeMsg{
+ Role: "user",
+ Content: []chatClaudeContentBlock{
+ {
+ Type: "tool_result",
+ ToolUseID: m.GetToolCallId(),
+ Content: m.GetContent(),
+ },
+ },
+ })
+ default:
+ continue
+ }
+ }
+
+ for _, td := range request.ToolDefinitions {
+ var schema any
+ if err := json.Unmarshal([]byte(td.ParametersSchema), &schema); err != nil {
+ return nil, errors.Errorf("failed to parse parameters schema for tool %s: %s", td.Name, err)
+ }
+ payload.Tools = append(payload.Tools, chatClaudeTool{
+ Name: td.Name,
+ Description: td.Description,
+ InputSchema: schema,
+ })
+ }
+
+ payloadBytes, err := json.Marshal(payload)
+ if err != nil {
+ return nil, errors.Errorf("failed to marshal Claude request: %s", err)
+ }
+
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", aiSetting.Endpoint, bytes.NewBuffer(payloadBytes))
+ if err != nil {
+ return nil, errors.Errorf("failed to create HTTP request: %s", err)
+ }
+ httpReq.Header.Set("Content-Type", "application/json")
+ httpReq.Header.Set("x-api-key", aiSetting.ApiKey)
+ if aiSetting.Version != "" {
+ httpReq.Header.Set("anthropic-version", aiSetting.Version)
+ } else {
+ httpReq.Header.Set("anthropic-version", "2023-06-01")
+ }
+
+ body, err := doHTTPRequest(ctx, httpReq, "Claude")
+ if err != nil {
+ return nil, err
+ }
+
+ var resp chatClaudeResponse
+ if err := json.Unmarshal(body, &resp); err != nil {
+ return nil, errors.Errorf("failed to unmarshal Claude response: %s", err)
+ }
+
+ result := &v1pb.AIChatResponse{}
+ if resp.Usage != nil {
+ result.Usage = newAIChatUsage(resp.Usage.InputTokens + resp.Usage.OutputTokens)
+ }
+ var textContent string
+ for _, rawBlock := range resp.Content {
+ var block chatClaudeContentBlock
+ if err := json.Unmarshal(rawBlock, &block); err != nil {
+ return nil, errors.Errorf("failed to parse Claude response content block: %s", err)
+ }
+ switch block.Type {
+ case "text":
+ textContent += block.Text
+ case "tool_use":
+ args, err := json.Marshal(block.Input)
+ if err != nil {
+ return nil, errors.Errorf("failed to marshal tool call input: %s", err)
+ }
+ result.ToolCalls = append(result.ToolCalls, &v1pb.AIChatToolCall{
+ Id: block.ID,
+ Name: block.Name,
+ Arguments: string(args),
+ })
+ default:
+ }
+ }
+ if len(result.ToolCalls) > 0 {
+ metadata, err := buildClaudeToolCallMetadata(resp.Content)
+ if err != nil {
+ return nil, errors.Errorf("failed to encode Claude tool metadata: %s", err)
+ }
+ for _, toolCall := range result.ToolCalls {
+ toolCall.Metadata = metadata
+ }
+ }
+ if textContent != "" {
+ result.Content = &textContent
+ }
+ return result, nil
+}
diff --git a/backend/plugin/ai/gemini.go b/backend/plugin/ai/gemini.go
new file mode 100644
index 0000000000..53c165889e
--- /dev/null
+++ b/backend/plugin/ai/gemini.go
@@ -0,0 +1,221 @@
+package ai
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+
+ "github.com/google/uuid"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+)
+
+// Gemini chat types with tool-calling support.
+
+type chatGeminiRequest struct {
+ Contents []chatGeminiContent `json:"contents"`
+ Tools []chatGeminiTool `json:"tools,omitempty"`
+}
+
+type chatGeminiContent struct {
+ Role string `json:"role"`
+ Parts []chatGeminiPart `json:"parts"`
+}
+
+type chatGeminiPart struct {
+ Text string `json:"text,omitempty"`
+ FunctionCall *chatGeminiFunctionCall `json:"functionCall,omitempty"`
+ FunctionResponse *chatGeminiFunctionResult `json:"functionResponse,omitempty"`
+ ThoughtSignature string `json:"thoughtSignature,omitempty"`
+}
+
+type chatGeminiFunctionCall struct {
+ Name string `json:"name"`
+ Args any `json:"args"`
+}
+
+type chatGeminiFunctionResult struct {
+ Name string `json:"name"`
+ Response any `json:"response"`
+}
+
+type chatGeminiTool struct {
+ FunctionDeclarations []chatGeminiFunctionDecl `json:"functionDeclarations"`
+}
+
+type chatGeminiFunctionDecl struct {
+ Name string `json:"name"`
+ Description string `json:"description"`
+ Parameters any `json:"parameters"`
+}
+
+type chatGeminiUsage struct {
+ TotalTokenCount int32 `json:"totalTokenCount"`
+}
+
+type chatGeminiResponse struct {
+ Candidates []struct {
+ Content struct {
+ Parts []chatGeminiResponsePart `json:"parts"`
+ } `json:"content"`
+ } `json:"candidates"`
+ UsageMetadata *chatGeminiUsage `json:"usageMetadata,omitempty"`
+}
+
+type chatGeminiResponsePart struct {
+ Text string `json:"text,omitempty"`
+ FunctionCall *chatGeminiFunctionCall `json:"functionCall,omitempty"`
+ ThoughtSignature string `json:"thoughtSignature,omitempty"`
+}
+
+func newGeminiToolCallID(name string) string {
+ return fmt.Sprintf("call_%s_%s", name, uuid.NewString())
+}
+
+func chatGemini(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
+ payload := chatGeminiRequest{}
+
+ for _, m := range request.Messages {
+ switch m.Role {
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_SYSTEM:
+ // Gemini handles system messages as the first user message.
+ payload.Contents = append(payload.Contents, chatGeminiContent{
+ Role: "user",
+ Parts: []chatGeminiPart{{Text: m.GetContent()}},
+ })
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER:
+ payload.Contents = append(payload.Contents, chatGeminiContent{
+ Role: "user",
+ Parts: []chatGeminiPart{{Text: m.GetContent()}},
+ })
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT:
+ var parts []chatGeminiPart
+ if m.Content != nil && *m.Content != "" {
+ parts = append(parts, chatGeminiPart{Text: *m.Content})
+ }
+ for _, tc := range m.ToolCalls {
+ var args any
+ if err := json.Unmarshal([]byte(tc.Arguments), &args); err != nil {
+ args = tc.Arguments
+ }
+ part := chatGeminiPart{
+ FunctionCall: &chatGeminiFunctionCall{
+ Name: tc.Name,
+ Args: args,
+ },
+ }
+ if tc.Metadata != nil {
+ part.ThoughtSignature = geminiThoughtSignatureFromMetadata(*tc.Metadata)
+ }
+ parts = append(parts, part)
+ }
+ payload.Contents = append(payload.Contents, chatGeminiContent{
+ Role: "model",
+ Parts: parts,
+ })
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_TOOL:
+ // Gemini uses functionResponse parts in a "user" role message.
+ // We need the tool name; get it from the tool call ID by searching prior messages.
+ toolName := getToolNameFromMessages(request.Messages, m.GetToolCallId())
+ var resultData any
+ if err := json.Unmarshal([]byte(m.GetContent()), &resultData); err != nil {
+ resultData = map[string]string{"result": m.GetContent()}
+ }
+ payload.Contents = append(payload.Contents, chatGeminiContent{
+ Role: "user",
+ Parts: []chatGeminiPart{
+ {
+ FunctionResponse: &chatGeminiFunctionResult{
+ Name: toolName,
+ Response: resultData,
+ },
+ },
+ },
+ })
+ default:
+ }
+ }
+
+ if len(request.ToolDefinitions) > 0 {
+ var decls []chatGeminiFunctionDecl
+ for _, td := range request.ToolDefinitions {
+ var params any
+ if err := json.Unmarshal([]byte(td.ParametersSchema), &params); err != nil {
+ return nil, errors.Errorf("failed to parse parameters schema for tool %s: %s", td.Name, err)
+ }
+ decls = append(decls, chatGeminiFunctionDecl{
+ Name: td.Name,
+ Description: td.Description,
+ Parameters: params,
+ })
+ }
+ payload.Tools = []chatGeminiTool{{FunctionDeclarations: decls}}
+ }
+
+ payloadBytes, err := json.Marshal(payload)
+ if err != nil {
+ return nil, errors.Errorf("failed to marshal Gemini request: %s", err)
+ }
+
+ requestURL, err := url.JoinPath(aiSetting.Endpoint, "models", aiSetting.Model+":generateContent")
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to build Gemini request URL")
+ }
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", requestURL, bytes.NewBuffer(payloadBytes))
+ if err != nil {
+ return nil, errors.Errorf("failed to create HTTP request: %s", err)
+ }
+ httpReq.Header.Set("Content-Type", "application/json")
+ httpReq.Header.Set("x-goog-api-key", aiSetting.ApiKey)
+
+ body, err := doHTTPRequest(ctx, httpReq, "Gemini")
+ if err != nil {
+ return nil, err
+ }
+
+ var resp chatGeminiResponse
+ if err := json.Unmarshal(body, &resp); err != nil {
+ return nil, errors.Errorf("failed to unmarshal Gemini response: %s", err)
+ }
+
+ result := &v1pb.AIChatResponse{}
+ if resp.UsageMetadata != nil {
+ result.Usage = newAIChatUsage(resp.UsageMetadata.TotalTokenCount)
+ }
+ if len(resp.Candidates) > 0 {
+ var textContent string
+ for _, part := range resp.Candidates[0].Content.Parts {
+ if part.Text != "" {
+ textContent += part.Text
+ }
+ if part.FunctionCall != nil {
+ args, err := json.Marshal(part.FunctionCall.Args)
+ if err != nil {
+ return nil, errors.Errorf("failed to marshal function call args: %s", err)
+ }
+ tc := &v1pb.AIChatToolCall{
+ Id: newGeminiToolCallID(part.FunctionCall.Name),
+ Name: part.FunctionCall.Name,
+ Arguments: string(args),
+ }
+ if part.ThoughtSignature != "" {
+ metadata, err := buildChatToolCallMetadata(nil, part.ThoughtSignature)
+ if err != nil {
+ return nil, errors.Errorf("failed to encode Gemini tool metadata: %s", err)
+ }
+ tc.Metadata = metadata
+ }
+ result.ToolCalls = append(result.ToolCalls, tc)
+ }
+ }
+ if textContent != "" {
+ result.Content = &textContent
+ }
+ }
+ return result, nil
+}
diff --git a/backend/plugin/ai/openai.go b/backend/plugin/ai/openai.go
new file mode 100644
index 0000000000..b70bfa5301
--- /dev/null
+++ b/backend/plugin/ai/openai.go
@@ -0,0 +1,537 @@
+package ai
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+)
+
+// OpenAI chat types with tool-calling support.
+
+type chatOpenAIRequest struct {
+ Model string `json:"model"`
+ Messages []chatOpenAIMessage `json:"messages"`
+ Tools []chatOpenAITool `json:"tools,omitempty"`
+}
+
+type chatOpenAIMessage struct {
+ Role string `json:"role"`
+ Content *string `json:"content"`
+ ToolCalls []json.RawMessage `json:"tool_calls,omitempty"`
+ ToolCallID string `json:"tool_call_id,omitempty"`
+}
+
+type chatOpenAITool struct {
+ Type string `json:"type"`
+ Function chatOpenAIFunction `json:"function"`
+}
+
+type chatOpenAIFunction struct {
+ Name string `json:"name"`
+ Description string `json:"description"`
+ Parameters any `json:"parameters"`
+}
+
+type chatOpenAIToolUse struct {
+ ID string `json:"id"`
+ Type string `json:"type"`
+ Function chatOpenAIFunctionCallRef `json:"function"`
+}
+
+type chatOpenAIFunctionCallRef struct {
+ Name string `json:"name"`
+ Arguments string `json:"arguments"`
+}
+
+type chatOpenAIUsage struct {
+ TotalTokens int32 `json:"total_tokens"`
+}
+
+type chatOpenAIResponse struct {
+ Choices []struct {
+ Message struct {
+ Role string `json:"role"`
+ Content *string `json:"content"`
+ ToolCalls []json.RawMessage `json:"tool_calls"`
+ } `json:"message"`
+ } `json:"choices"`
+ Usage *chatOpenAIUsage `json:"usage,omitempty"`
+}
+
+// chatOpenAIToolCallParsed extracts the fields we need from a raw tool call JSON.
+type chatOpenAIToolCallParsed struct {
+ ID string `json:"id"`
+ Function struct {
+ Name string `json:"name"`
+ Arguments string `json:"arguments"`
+ } `json:"function"`
+}
+
+type chatToolCallMetadata struct {
+ OpenAIToolCall json.RawMessage `json:"openAIToolCall,omitempty"`
+ GeminiThoughtSignature string `json:"geminiThoughtSignature,omitempty"`
+ ResponsesOutput []json.RawMessage `json:"responsesOutput,omitempty"`
+ ClaudeContent []json.RawMessage `json:"claudeContent,omitempty"`
+}
+
+type chatOpenAIToolCallProviderFields struct {
+ ExtraContent struct {
+ Google struct {
+ ThoughtSignature string `json:"thought_signature,omitempty"`
+ } `json:"google,omitempty"`
+ } `json:"extra_content,omitempty"`
+}
+
+func parseChatToolCallMetadata(raw string) (chatToolCallMetadata, bool) {
+ metadataBytes := bytes.TrimSpace([]byte(raw))
+ if len(metadataBytes) == 0 {
+ return chatToolCallMetadata{}, false
+ }
+ var metadata chatToolCallMetadata
+ if err := json.Unmarshal(metadataBytes, &metadata); err != nil {
+ return chatToolCallMetadata{}, false
+ }
+ if len(metadata.OpenAIToolCall) == 0 && metadata.GeminiThoughtSignature == "" && len(metadata.ResponsesOutput) == 0 && len(metadata.ClaudeContent) == 0 {
+ return chatToolCallMetadata{}, false
+ }
+ return metadata, true
+}
+
+func buildChatToolCallMetadata(rawOpenAIToolCall json.RawMessage, geminiThoughtSignature string) (*string, error) {
+ metadata := chatToolCallMetadata{
+ OpenAIToolCall: rawOpenAIToolCall,
+ GeminiThoughtSignature: geminiThoughtSignature,
+ }
+ if metadata.GeminiThoughtSignature == "" {
+ metadata.GeminiThoughtSignature = extractGeminiThoughtSignatureFromOpenAIToolCall(rawOpenAIToolCall)
+ }
+ if len(metadata.OpenAIToolCall) == 0 && metadata.GeminiThoughtSignature == "" {
+ return nil, nil
+ }
+ metadataBytes, err := json.Marshal(metadata)
+ if err != nil {
+ return nil, err
+ }
+ return new(string(metadataBytes)), nil
+}
+
+func openAIToolCallFromMetadata(raw string) json.RawMessage {
+ if metadata, ok := parseChatToolCallMetadata(raw); ok {
+ return metadata.OpenAIToolCall
+ }
+ metadataBytes := bytes.TrimSpace([]byte(raw))
+ if len(metadataBytes) == 0 || !json.Valid(metadataBytes) {
+ return nil
+ }
+ return json.RawMessage(metadataBytes)
+}
+
+func geminiThoughtSignatureFromMetadata(raw string) string {
+ if metadata, ok := parseChatToolCallMetadata(raw); ok {
+ if metadata.GeminiThoughtSignature != "" {
+ return metadata.GeminiThoughtSignature
+ }
+ return extractGeminiThoughtSignatureFromOpenAIToolCall(metadata.OpenAIToolCall)
+ }
+ metadataBytes := bytes.TrimSpace([]byte(raw))
+ if len(metadataBytes) == 0 {
+ return ""
+ }
+ if json.Valid(metadataBytes) {
+ return extractGeminiThoughtSignatureFromOpenAIToolCall(json.RawMessage(metadataBytes))
+ }
+ return string(metadataBytes)
+}
+
+func responsesOutputFromMetadata(raw string) []json.RawMessage {
+ if metadata, ok := parseChatToolCallMetadata(raw); ok {
+ return metadata.ResponsesOutput
+ }
+ return nil
+}
+
+func buildResponsesToolCallMetadata(output []json.RawMessage) (*string, error) {
+ metadataBytes, err := json.Marshal(chatToolCallMetadata{ResponsesOutput: output})
+ if err != nil {
+ return nil, err
+ }
+ return new(string(metadataBytes)), nil
+}
+
+func claudeContentFromMetadata(raw string) []json.RawMessage {
+ if metadata, ok := parseChatToolCallMetadata(raw); ok {
+ return metadata.ClaudeContent
+ }
+ return nil
+}
+
+func buildClaudeToolCallMetadata(content []json.RawMessage) (*string, error) {
+ metadataBytes, err := json.Marshal(chatToolCallMetadata{ClaudeContent: content})
+ if err != nil {
+ return nil, err
+ }
+ return new(string(metadataBytes)), nil
+}
+
+func extractGeminiThoughtSignatureFromOpenAIToolCall(raw json.RawMessage) string {
+ if len(raw) == 0 {
+ return ""
+ }
+ var providerFields chatOpenAIToolCallProviderFields
+ if err := json.Unmarshal(raw, &providerFields); err != nil {
+ return ""
+ }
+ return providerFields.ExtraContent.Google.ThoughtSignature
+}
+
+func chatOpenAI(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
+ if isOpenAIResponsesEndpoint(aiSetting.Endpoint) {
+ return chatOpenAIResponses(ctx, aiSetting, request)
+ }
+ return chatOpenAIChatCompletions(ctx, aiSetting, request)
+}
+
+func isOpenAIResponsesEndpoint(endpoint string) bool {
+ requestURL, err := url.Parse(endpoint)
+ return err == nil && strings.HasSuffix(strings.TrimRight(requestURL.Path, "/"), "/responses")
+}
+
+func chatOpenAIChatCompletions(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
+ payload := chatOpenAIRequest{
+ Model: aiSetting.Model,
+ }
+
+ for _, m := range request.Messages {
+ msg := chatOpenAIMessage{
+ Role: chatMessageRoleToOpenAI(m.Role),
+ }
+ if m.Content != nil {
+ msg.Content = m.Content
+ }
+ if m.ToolCallId != nil {
+ msg.ToolCallID = *m.ToolCallId
+ }
+ for _, tc := range m.ToolCalls {
+ if tc.Metadata != nil {
+ if rawToolCall := openAIToolCallFromMetadata(*tc.Metadata); len(rawToolCall) > 0 {
+ // Replay the raw tool call JSON exactly as received from the provider.
+ // This preserves provider-specific fields like Gemini's thought_signature.
+ msg.ToolCalls = append(msg.ToolCalls, rawToolCall)
+ continue
+ }
+ }
+ // Construct a standard OpenAI tool call.
+ raw, _ := json.Marshal(chatOpenAIToolUse{
+ ID: tc.Id,
+ Type: "function",
+ Function: chatOpenAIFunctionCallRef{
+ Name: tc.Name,
+ Arguments: tc.Arguments,
+ },
+ })
+ msg.ToolCalls = append(msg.ToolCalls, json.RawMessage(raw))
+ }
+ payload.Messages = append(payload.Messages, msg)
+ }
+
+ for _, td := range request.ToolDefinitions {
+ var params any
+ if err := json.Unmarshal([]byte(td.ParametersSchema), &params); err != nil {
+ return nil, errors.Errorf("failed to parse parameters schema for tool %s: %s", td.Name, err)
+ }
+ payload.Tools = append(payload.Tools, chatOpenAITool{
+ Type: "function",
+ Function: chatOpenAIFunction{
+ Name: td.Name,
+ Description: td.Description,
+ Parameters: params,
+ },
+ })
+ }
+
+ payloadBytes, err := json.Marshal(payload)
+ if err != nil {
+ return nil, errors.Errorf("failed to marshal OpenAI request: %s", err)
+ }
+
+ httpReq, err := http.NewRequestWithContext(ctx, "POST", aiSetting.Endpoint, bytes.NewBuffer(payloadBytes))
+ if err != nil {
+ return nil, errors.Errorf("failed to create HTTP request: %s", err)
+ }
+ httpReq.Header.Set("Content-Type", "application/json")
+ if aiSetting.Provider == storepb.AISetting_AZURE_OPENAI {
+ httpReq.Header.Set("api-key", aiSetting.ApiKey)
+ } else {
+ httpReq.Header.Set("Authorization", fmt.Sprintf("Bearer %s", aiSetting.ApiKey))
+ }
+
+ body, err := doHTTPRequest(ctx, httpReq, "OpenAI")
+ if err != nil {
+ return nil, err
+ }
+
+ var resp chatOpenAIResponse
+ if err := json.Unmarshal(body, &resp); err != nil {
+ return nil, errors.Errorf("failed to unmarshal OpenAI response: %s", err)
+ }
+
+ result := &v1pb.AIChatResponse{}
+ if resp.Usage != nil {
+ result.Usage = newAIChatUsage(resp.Usage.TotalTokens)
+ }
+ if len(resp.Choices) > 0 {
+ msg := resp.Choices[0].Message
+ result.Content = msg.Content
+ for _, rawTC := range msg.ToolCalls {
+ var parsed chatOpenAIToolCallParsed
+ if err := json.Unmarshal(rawTC, &parsed); err != nil {
+ return nil, errors.Errorf("failed to parse tool call: %s", err)
+ }
+ // Store provider-specific tool metadata in a structured envelope so each
+ // adapter can replay only the fields it understands.
+ metadata, err := buildChatToolCallMetadata(rawTC, "")
+ if err != nil {
+ return nil, errors.Errorf("failed to encode tool call metadata: %s", err)
+ }
+ toolCall := &v1pb.AIChatToolCall{
+ Id: parsed.ID,
+ Name: parsed.Function.Name,
+ Arguments: parsed.Function.Arguments,
+ Metadata: metadata,
+ }
+ result.ToolCalls = append(result.ToolCalls, toolCall)
+ }
+ }
+ return result, nil
+}
+
+type responsesOpenAIRequest struct {
+ Model string `json:"model"`
+ Input []json.RawMessage `json:"input"`
+ Store bool `json:"store"`
+ Include []string `json:"include,omitempty"`
+ Tools []responsesOpenAITool `json:"tools,omitempty"`
+}
+
+type responsesOpenAITool struct {
+ Type string `json:"type"`
+ Name string `json:"name"`
+ Description string `json:"description"`
+ Parameters any `json:"parameters"`
+}
+
+type responsesOpenAIResponse struct {
+ Output []json.RawMessage `json:"output"`
+ Usage *chatOpenAIUsage `json:"usage,omitempty"`
+ Error *struct {
+ Message string `json:"message"`
+ } `json:"error,omitempty"`
+ Status string `json:"status,omitempty"`
+ IncompleteDetails *struct {
+ Reason string `json:"reason"`
+ } `json:"incomplete_details,omitempty"`
+}
+
+type responsesOpenAIOutputItem struct {
+ Type string `json:"type"`
+ CallID string `json:"call_id"`
+ Name string `json:"name"`
+ Arguments string `json:"arguments"`
+ Content []struct {
+ Type string `json:"type"`
+ Text string `json:"text"`
+ Refusal string `json:"refusal"`
+ } `json:"content"`
+}
+
+func chatOpenAIResponses(ctx context.Context, aiSetting *storepb.AISetting, request *v1pb.AIChatRequest) (*v1pb.AIChatResponse, error) {
+ payload := responsesOpenAIRequest{
+ Model: aiSetting.Model,
+ Store: false,
+ Include: []string{"reasoning.encrypted_content"},
+ }
+ for _, message := range request.Messages {
+ items, err := responsesInputFromMessage(message)
+ if err != nil {
+ return nil, err
+ }
+ payload.Input = append(payload.Input, items...)
+ }
+
+ for _, definition := range request.ToolDefinitions {
+ var parameters any
+ if err := json.Unmarshal([]byte(definition.ParametersSchema), &parameters); err != nil {
+ return nil, errors.Errorf("failed to parse parameters schema for tool %s: %s", definition.Name, err)
+ }
+ payload.Tools = append(payload.Tools, responsesOpenAITool{
+ Type: "function",
+ Name: definition.Name,
+ Description: definition.Description,
+ Parameters: parameters,
+ })
+ }
+
+ payloadBytes, err := json.Marshal(payload)
+ if err != nil {
+ return nil, errors.Errorf("failed to marshal OpenAI Responses request: %s", err)
+ }
+ httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, aiSetting.Endpoint, bytes.NewBuffer(payloadBytes))
+ if err != nil {
+ return nil, errors.Errorf("failed to create OpenAI Responses request: %s", err)
+ }
+ httpReq.Header.Set("Content-Type", "application/json")
+ if aiSetting.Provider == storepb.AISetting_AZURE_OPENAI {
+ httpReq.Header.Set("api-key", aiSetting.ApiKey)
+ } else {
+ httpReq.Header.Set("Authorization", fmt.Sprintf("Bearer %s", aiSetting.ApiKey))
+ }
+
+ body, err := doHTTPRequest(ctx, httpReq, "OpenAI")
+ if err != nil {
+ return nil, err
+ }
+ var response responsesOpenAIResponse
+ if err := json.Unmarshal(body, &response); err != nil {
+ return nil, errors.Errorf("failed to unmarshal OpenAI Responses response: %s", err)
+ }
+ if response.Error != nil {
+ return nil, errors.Errorf("OpenAI Responses API returned error: %s", response.Error.Message)
+ }
+ if response.Status == "incomplete" {
+ reason := ""
+ if response.IncompleteDetails != nil {
+ reason = response.IncompleteDetails.Reason
+ }
+ return nil, errors.Errorf("OpenAI Responses API returned an incomplete response: %s", reason)
+ }
+
+ result := &v1pb.AIChatResponse{}
+ if response.Usage != nil {
+ result.Usage = newAIChatUsage(response.Usage.TotalTokens)
+ }
+ var content strings.Builder
+ for _, rawOutput := range response.Output {
+ var output responsesOpenAIOutputItem
+ if err := json.Unmarshal(rawOutput, &output); err != nil {
+ return nil, errors.Errorf("failed to parse OpenAI Responses output item: %s", err)
+ }
+ switch output.Type {
+ case "message":
+ for _, part := range output.Content {
+ switch part.Type {
+ case "output_text":
+ content.WriteString(part.Text)
+ case "refusal":
+ content.WriteString(part.Refusal)
+ default:
+ continue
+ }
+ }
+ case "function_call":
+ result.ToolCalls = append(result.ToolCalls, &v1pb.AIChatToolCall{
+ Id: output.CallID,
+ Name: output.Name,
+ Arguments: output.Arguments,
+ })
+ default:
+ continue
+ }
+ }
+ if content.Len() > 0 {
+ text := content.String()
+ result.Content = &text
+ }
+ if len(result.ToolCalls) > 0 {
+ metadata, err := buildResponsesToolCallMetadata(response.Output)
+ if err != nil {
+ return nil, errors.Errorf("failed to encode OpenAI Responses tool metadata: %s", err)
+ }
+ result.ToolCalls[0].Metadata = metadata
+ }
+ return result, nil
+}
+
+func responsesInputFromMessage(message *v1pb.AIChatMessage) ([]json.RawMessage, error) {
+ if message.Role == v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_TOOL {
+ if message.ToolCallId == nil || *message.ToolCallId == "" {
+ return nil, errors.New("OpenAI Responses tool result is missing a tool call ID")
+ }
+ output := ""
+ if message.Content != nil {
+ output = *message.Content
+ }
+ item, err := json.Marshal(map[string]string{
+ "type": "function_call_output",
+ "call_id": *message.ToolCallId,
+ "output": output,
+ })
+ return []json.RawMessage{item}, err
+ }
+
+ if message.Role == v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT && len(message.ToolCalls) > 0 {
+ for _, toolCall := range message.ToolCalls {
+ if toolCall.Metadata == nil {
+ continue
+ }
+ if output := responsesOutputFromMetadata(*toolCall.Metadata); len(output) > 0 {
+ return output, nil
+ }
+ }
+ }
+
+ items := make([]json.RawMessage, 0, 1+len(message.ToolCalls))
+ if message.Content != nil {
+ if message.Role == v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT {
+ item, err := json.Marshal(map[string]any{
+ "type": "message",
+ "role": "assistant",
+ "status": "completed",
+ "content": []map[string]string{{
+ "type": "output_text",
+ "text": *message.Content,
+ }},
+ })
+ if err != nil {
+ return nil, err
+ }
+ items = append(items, item)
+ } else {
+ role := chatMessageRoleToOpenAI(message.Role)
+ if message.Role == v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_SYSTEM {
+ role = "developer"
+ }
+ item, err := json.Marshal(map[string]string{
+ "role": role,
+ "content": *message.Content,
+ })
+ if err != nil {
+ return nil, err
+ }
+ items = append(items, item)
+ }
+ }
+ if message.Role == v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT {
+ for _, toolCall := range message.ToolCalls {
+ item, err := json.Marshal(map[string]string{
+ "type": "function_call",
+ "call_id": toolCall.Id,
+ "name": toolCall.Name,
+ "arguments": toolCall.Arguments,
+ })
+ if err != nil {
+ return nil, err
+ }
+ items = append(items, item)
+ }
+ }
+ return items, nil
+}
diff --git a/backend/plugin/ai/shared.go b/backend/plugin/ai/shared.go
new file mode 100644
index 0000000000..b9f5b37d6f
--- /dev/null
+++ b/backend/plugin/ai/shared.go
@@ -0,0 +1,69 @@
+package ai
+
+import (
+ "context"
+ "io"
+ "net/http"
+
+ "github.com/pkg/errors"
+
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+)
+
+func newAIChatUsage(totalTokens int32) *v1pb.AIChatUsage {
+ if totalTokens <= 0 {
+ return nil
+ }
+ return &v1pb.AIChatUsage{
+ TotalTokens: totalTokens,
+ }
+}
+
+// doHTTPRequest executes an HTTP request and returns the response body.
+func doHTTPRequest(_ context.Context, httpReq *http.Request, provider string) ([]byte, error) {
+ client := &http.Client{}
+ httpResp, err := client.Do(httpReq)
+ if err != nil {
+ return nil, errors.Errorf("failed to send HTTP request to %s: %s", provider, err)
+ }
+ defer httpResp.Body.Close()
+
+ body, err := io.ReadAll(httpResp.Body)
+ if err != nil {
+ return nil, errors.Errorf("failed to read %s response body: %s", provider, err)
+ }
+
+ if httpResp.StatusCode != http.StatusOK {
+ return nil, errors.Errorf("%s API returned status %d: %s", provider, httpResp.StatusCode, string(body))
+ }
+
+ return body, nil
+}
+
+// chatMessageRoleToOpenAI converts a proto role enum to OpenAI role string.
+func chatMessageRoleToOpenAI(role v1pb.AIChatMessageRole) string {
+ switch role {
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_SYSTEM:
+ return "system"
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_USER:
+ return "user"
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_ASSISTANT:
+ return "assistant"
+ case v1pb.AIChatMessageRole_AI_CHAT_MESSAGE_ROLE_TOOL:
+ return "tool"
+ default:
+ return "user"
+ }
+}
+
+// getToolNameFromMessages finds the tool name for a given tool call ID by searching assistant messages.
+func getToolNameFromMessages(messages []*v1pb.AIChatMessage, toolCallID string) string {
+ for _, m := range messages {
+ for _, tc := range m.ToolCalls {
+ if tc.Id == toolCallID {
+ return tc.Name
+ }
+ }
+ }
+ return toolCallID
+}
diff --git a/frontend/src/locales/en-US.json b/frontend/src/locales/en-US.json
index 8ac8f3e0f1..1e3a3eff70 100644
--- a/frontend/src/locales/en-US.json
+++ b/frontend/src/locales/en-US.json
@@ -2380,12 +2380,17 @@
"enable-ai-assistant": "Enable AI Assistant",
"enabled-in-saas": "Gemini AI is enabled automatically in the SaaS mode.",
"endpoint": {
- "description": "Supply private deployment of API Endpoint.",
+ "description": "Enter the API endpoint for the custom model.",
+ "openai-description": "Use a /responses endpoint for the Responses API or /chat/completions for the Chat Completions API.",
"self": "API Endpoint"
},
"model": {
- "description": "Supply private deployment of model name.",
- "self": "Model Name"
+ "custom": "Custom model",
+ "deployment": "Deployment Name",
+ "deployment-description": "The Azure OpenAI deployment name. It may differ from the model.",
+ "description": "Select a supported model, or choose Custom model to enter another model and endpoint.",
+ "name": "Model Name",
+ "self": "Model"
},
"provider": {
"azure_open_ai": "Azure OpenAI",
diff --git a/frontend/src/locales/es-ES.json b/frontend/src/locales/es-ES.json
index e8018c1263..5c17a68bcf 100644
--- a/frontend/src/locales/es-ES.json
+++ b/frontend/src/locales/es-ES.json
@@ -2380,12 +2380,17 @@
"enable-ai-assistant": "Habilitar el Asistente de IA",
"enabled-in-saas": "Gemini AI se habilita automáticamente en el modo SaaS.",
"endpoint": {
- "description": "Proporcione una implementación privada del Punto de conexión de API.",
+ "description": "Introduzca el endpoint de API para el modelo personalizado.",
+ "openai-description": "Use un endpoint /responses para la API Responses o /chat/completions para la API Chat Completions.",
"self": "Punto de conexión de API"
},
"model": {
- "description": "Suministro de implementación privada del nombre del modelo.",
- "self": "Nombre del modelo"
+ "custom": "Modelo personalizado",
+ "deployment": "Nombre de implementación",
+ "deployment-description": "El nombre de la implementación de Azure OpenAI. Puede diferir del modelo.",
+ "description": "Seleccione un modelo compatible o elija un modelo personalizado para introducir otro modelo y endpoint.",
+ "name": "Nombre del modelo",
+ "self": "Modelo"
},
"provider": {
"azure_open_ai": "Azure OpenAI",
diff --git a/frontend/src/locales/ja-JP.json b/frontend/src/locales/ja-JP.json
index bde557c1ee..e70bad3e61 100644
--- a/frontend/src/locales/ja-JP.json
+++ b/frontend/src/locales/ja-JP.json
@@ -2380,12 +2380,17 @@
"enable-ai-assistant": "AIアシスタントを有効にする",
"enabled-in-saas": "Gemini AI は SaaS モードで自動的に有効になります。",
"endpoint": {
- "description": "プライベート展開用の API エンドポイントを提供します。",
+ "description": "カスタムモデルの API エンドポイントを入力します。",
+ "openai-description": "Responses API には /responses、Chat Completions API には /chat/completions のエンドポイントを使用します。",
"self": "API エンドポイント"
},
"model": {
- "description": "供給プライベートデプロイメントのモデル名。",
- "self": "モデル名"
+ "custom": "カスタムモデル",
+ "deployment": "デプロイ名",
+ "deployment-description": "Azure OpenAI のデプロイ名です。モデル名と異なる場合があります。",
+ "description": "対応モデルを選択するか、カスタムモデルを選択して別のモデルとエンドポイントを入力します。",
+ "name": "モデル名",
+ "self": "モデル"
},
"provider": {
"azure_open_ai": "Azure OpenAI",
diff --git a/frontend/src/locales/vi-VN.json b/frontend/src/locales/vi-VN.json
index 6bcdf292c2..bc84d26663 100644
--- a/frontend/src/locales/vi-VN.json
+++ b/frontend/src/locales/vi-VN.json
@@ -2380,12 +2380,17 @@
"enable-ai-assistant": "Bật Trợ lý AI",
"enabled-in-saas": "Gemini AI được bật tự động trong chế độ SaaS.",
"endpoint": {
- "description": "Cung cấp triển khai riêng của Điểm cuối API.",
+ "description": "Nhập endpoint API cho model tùy chỉnh.",
+ "openai-description": "Dùng endpoint /responses cho Responses API hoặc /chat/completions cho Chat Completions API.",
"self": "Điểm cuối API"
},
"model": {
- "description": "Cung cấp triển khai riêng của tên mô hình.",
- "self": "Tên mô hình"
+ "custom": "Model tùy chỉnh",
+ "deployment": "Tên triển khai",
+ "deployment-description": "Tên triển khai Azure OpenAI. Có thể khác với model.",
+ "description": "Chọn model được hỗ trợ hoặc chọn model tùy chỉnh để nhập model và endpoint khác.",
+ "name": "Tên model",
+ "self": "Model"
},
"provider": {
"azure_open_ai": "Azure OpenAI",
diff --git a/frontend/src/locales/zh-CN.json b/frontend/src/locales/zh-CN.json
index 582617e525..30a349bb51 100644
--- a/frontend/src/locales/zh-CN.json
+++ b/frontend/src/locales/zh-CN.json
@@ -2380,12 +2380,17 @@
"enable-ai-assistant": "启用 AI 助手",
"enabled-in-saas": "Gemini AI 在 SaaS 模式下自动启用。",
"endpoint": {
- "description": "提供私有化部署的 API Endpoint。",
+ "description": "请输入自定义模型的 API 端点。",
+ "openai-description": "Responses API 使用 /responses 端点,Chat Completions API 使用 /chat/completions 端点。",
"self": "API 端点"
},
"model": {
- "description": "提供私有化部署的模型名称。",
- "self": "模型名称"
+ "custom": "自定义模型",
+ "deployment": "部署名称",
+ "deployment-description": "Azure OpenAI 的部署名称,可以与模型名称不同。",
+ "description": "选择支持的模型,或选择自定义模型以输入其他模型和端点。",
+ "name": "模型名称",
+ "self": "模型"
},
"provider": {
"azure_open_ai": "Azure OpenAI",
diff --git a/frontend/src/routes/workspace/general/AIAugmentationSection.tsx b/frontend/src/routes/workspace/general/AIAugmentationSection.tsx
index 7c5ff4e1fc..6da1c8dd7b 100644
--- a/frontend/src/routes/workspace/general/AIAugmentationSection.tsx
+++ b/frontend/src/routes/workspace/general/AIAugmentationSection.tsx
@@ -37,7 +37,11 @@ import {
SettingValueSchema,
} from "@/types/proto-es/v1/setting_service_pb";
import { hasWorkspacePermissionV2 } from "@/utils";
-import { PROVIDER_DEFAULTS } from "./aiProviderDefaults";
+import {
+ getModelEndpoint,
+ PROVIDER_DEFAULTS,
+ PROVIDER_MODELS,
+} from "./aiProviderDefaults";
import type { SectionHandle } from "./useSettingSection";
interface AIAugmentationSectionProps {
@@ -60,6 +64,17 @@ const PROVIDER_OPTIONS = [
AISetting_Provider.CLAUDE,
] as const;
+const CUSTOM_MODEL = "__custom__";
+
+function getSelectedModel(state: AIState): string {
+ return (
+ (PROVIDER_MODELS[state.provider] ?? []).find(
+ (model) =>
+ model.value === state.model && model.endpoint === state.endpoint
+ )?.value ?? CUSTOM_MODEL
+ );
+}
+
export const AIAugmentationSection = forwardRef<
SectionHandle,
AIAugmentationSectionProps
@@ -92,6 +107,9 @@ export const AIAugmentationSection = forwardRef<
}, [aiSetting]);
const [state, setState] = useState<AIState>(getInitialState);
+ const [selectedModel, setSelectedModel] = useState(() =>
+ getSelectedModel(getInitialState())
+ );
// Re-sync state when the store value changes (e.g. after initial fetch).
const prevAiSettingRef = useRef(aiSetting);
@@ -99,6 +117,7 @@ export const AIAugmentationSection = forwardRef<
if (prevAiSettingRef.current !== aiSetting) {
prevAiSettingRef.current = aiSetting;
setState(getInitialState());
+ setSelectedModel(getSelectedModel(getInitialState()));
}
}, [aiSetting, getInitialState]);
@@ -139,6 +158,7 @@ export const AIAugmentationSection = forwardRef<
const revert = useCallback(() => {
setState(getInitialState());
+ setSelectedModel(getSelectedModel(getInitialState()));
}, [getInitialState]);
const update = useCallback(async () => {
@@ -178,6 +198,7 @@ export const AIAugmentationSection = forwardRef<
const onProviderChange = (provider: AISetting_Provider) => {
const defaults = PROVIDER_DEFAULTS[provider];
+ setSelectedModel(defaults.model);
setState((s) => ({
...s,
provider,
@@ -187,7 +208,35 @@ export const AIAugmentationSection = forwardRef<
}));
};
+ const onModelChange = (modelName: string | null) => {
+ if (!modelName) {
+ return;
+ }
+ setSelectedModel(modelName);
+ if (modelName === CUSTOM_MODEL) {
+ return;
+ }
+ const model = (PROVIDER_MODELS[state.provider] ?? []).find(
+ (model) => model.value === modelName
+ );
+ if (!model) {
+ return;
+ }
+ setState((s) => ({
+ ...s,
+ endpoint: getModelEndpoint(s.provider, s.endpoint, model),
+ model: model.value,
+ }));
+ };
+
const toggleEnabled = (enabled: boolean) => {
+ if (enabled && (!state.endpoint || !state.model)) {
+ setSelectedModel(
+ state.endpoint || state.model
+ ? CUSTOM_MODEL
+ : PROVIDER_DEFAULTS[state.provider].model
+ );
+ }
setState((s) => {
if (enabled) {
const defaults = PROVIDER_DEFAULTS[s.provider];
@@ -202,6 +251,11 @@ export const AIAugmentationSection = forwardRef<
});
};
+ const isCustomModel = selectedModel === CUSTOM_MODEL;
+ const isAzureOpenAI = state.provider === AISetting_Provider.AZURE_OPENAI;
+ const isOpenAICompatible =
+ state.provider === AISetting_Provider.OPEN_AI || isAzureOpenAI;
+
const providerLabel = (provider: AISetting_Provider) => {
switch (provider) {
case AISetting_Provider.OPEN_AI:
@@ -337,30 +391,6 @@ export const AIAugmentationSection = forwardRef<
/>
</FormField>
- {/* Endpoint */}
- <FormField
- title={t(
- "settings.general.workspace.ai-assistant.endpoint.self"
- )}
- description={t(
- "settings.general.workspace.ai-assistant.endpoint.description"
- )}
- >
- <Input
- value={state.endpoint}
- required
- disabled={!canEdit}
- placeholder={providerDefault.endpoint}
- onChange={(e) =>
- setState((s) => ({
- ...s,
- endpoint: e.target.value,
- }))
- }
- />
- </FormField>
-
- {/* Model */}
<FormField
title={t(
"settings.general.workspace.ai-assistant.model.self"
@@ -369,15 +399,96 @@ export const AIAugmentationSection = forwardRef<
"settings.general.workspace.ai-assistant.model.description"
)}
>
- <Input
- value={state.model}
- required
+ <Select
+ value={selectedModel}
disabled={!canEdit}
- onChange={(e) =>
- setState((s) => ({ ...s, model: e.target.value }))
- }
- />
+ onValueChange={onModelChange}
+ >
+ <SelectTrigger className="w-48">
+ <SelectValue>
+ {selectedModel === CUSTOM_MODEL
+ ? t(
+ "settings.general.workspace.ai-assistant.model.custom"
+ )
+ : selectedModel}
+ </SelectValue>
+ </SelectTrigger>
+ <SelectContent>
+ {(PROVIDER_MODELS[state.provider] ?? []).map(
+ (model) => (
+ <SelectItem key={model.value} value={model.value}>
+ {model.value}
+ </SelectItem>
+ )
+ )}
+ <SelectItem value={CUSTOM_MODEL}>
+ {t(
+ "settings.general.workspace.ai-assistant.model.custom"
+ )}
+ </SelectItem>
+ </SelectContent>
+ </Select>
</FormField>
+
+ {isCustomModel && (
+ <FormField
+ title={
+ isAzureOpenAI
+ ? t(
+ "settings.general.workspace.ai-assistant.model.deployment"
+ )
+ : t(
+ "settings.general.workspace.ai-assistant.model.name"
+ )
+ }
+ description={
+ isAzureOpenAI
+ ? t(
+ "settings.general.workspace.ai-assistant.model.deployment-description"
+ )
+ : undefined
+ }
+ >
+ <Input
+ value={state.model}
+ required
+ disabled={!canEdit}
+ onChange={(e) =>
+ setState((s) => ({ ...s, model: e.target.value }))
+ }
+ />
+ </FormField>
+ )}
+
+ {(isCustomModel || isAzureOpenAI) && (
+ <FormField
+ title={t(
+ "settings.general.workspace.ai-assistant.endpoint.self"
+ )}
+ description={
+ isOpenAICompatible
+ ? t(
+ "settings.general.workspace.ai-assistant.endpoint.openai-description"
+ )
+ : t(
+ "settings.general.workspace.ai-assistant.endpoint.description"
+ )
+ }
+ >
+ <Input
+ value={state.endpoint}
+ required
+ disabled={!canEdit}
+ placeholder={providerDefault.endpoint}
+ onChange={(e) =>
+ setState((s) => ({
+ ...s,
+ endpoint: e.target.value,
+ }))
+ }
+ />
+ </FormField>
+ )}
</>
)}
</>
diff --git a/frontend/src/routes/workspace/general/aiProviderDefaults.test.ts b/frontend/src/routes/workspace/general/aiProviderDefaults.test.ts
index ef1255b445..d0cd54df13 100644
--- a/frontend/src/routes/workspace/general/aiProviderDefaults.test.ts
+++ b/frontend/src/routes/workspace/general/aiProviderDefaults.test.ts
@@ -1,18 +1,154 @@
import { describe, expect, test } from "vitest";
import { AISetting_Provider } from "@/types/proto-es/v1/setting_service_pb";
-import { PROVIDER_DEFAULTS } from "./aiProviderDefaults";
+import {
+ getModelEndpoint,
+ PROVIDER_DEFAULTS,
+ PROVIDER_MODELS,
+} from "./aiProviderDefaults";
describe("PROVIDER_DEFAULTS", () => {
test("uses current default model IDs for built-in AI providers", () => {
- expect(PROVIDER_DEFAULTS[AISetting_Provider.OPEN_AI].model).toBe("gpt-5.5");
+ expect(PROVIDER_DEFAULTS[AISetting_Provider.OPEN_AI].model).toBe(
+ "gpt-5.6-terra"
+ );
expect(PROVIDER_DEFAULTS[AISetting_Provider.AZURE_OPENAI].model).toBe(
- "gpt-5.5"
+ "gpt-5.6-terra"
);
expect(PROVIDER_DEFAULTS[AISetting_Provider.GEMINI].model).toBe(
- "gemini-3.5-flash"
+ "gemini-3.8-flash"
);
expect(PROVIDER_DEFAULTS[AISetting_Provider.CLAUDE].model).toBe(
"claude-sonnet-5"
);
});
+
+ test("includes current supported models", () => {
+ expect(
+ PROVIDER_MODELS[AISetting_Provider.OPEN_AI].map((model) => model.value)
+ ).toEqual(
+ expect.arrayContaining([
+ "gpt-6-astra",
+ "gpt-5.6-sol",
+ "gpt-5.6-terra",
+ "gpt-5.6-luna",
+ ])
+ );
+ expect(
+ PROVIDER_MODELS[AISetting_Provider.AZURE_OPENAI].map(
+ (model) => model.value
+ )
+ ).toEqual(
+ expect.arrayContaining([
+ "gpt-6-astra",
+ "gpt-5.6-sol",
+ "gpt-5.6-terra",
+ "gpt-5.6-luna",
+ ])
+ );
+ expect(
+ PROVIDER_MODELS[AISetting_Provider.GEMINI].map((model) => model.value)
+ ).toEqual(
+ expect.arrayContaining([
+ "gemini-3.8-flash",
+ "gemini-3.7-flash",
+ "gemini-3.6-flash",
+ "gemini-3.5-flash-lite",
+ ])
+ );
+ expect(
+ PROVIDER_MODELS[AISetting_Provider.CLAUDE].map((model) => model.value)
+ ).toEqual(
+ expect.arrayContaining([
+ "claude-fable-5-1",
+ "claude-opus-5",
+ "claude-haiku-4-5",
+ ])
+ );
+ });
+
+ test("uses the Responses API for current OpenAI models", () => {
+ const modelNames = [
+ "gpt-6-astra",
+ "gpt-5.6-sol",
+ "gpt-5.6-terra",
+ "gpt-5.6-luna",
+ "gpt-5.5",
+ ];
+ for (const provider of [
+ AISetting_Provider.OPEN_AI,
+ AISetting_Provider.AZURE_OPENAI,
+ ]) {
+ for (const modelName of modelNames) {
+ const model = PROVIDER_MODELS[provider].find(
+ (model) => model.value === modelName
+ );
+ expect(model?.endpoint).toContain("/responses");
+ }
+ }
+ });
+
+ test("keeps each provider default aligned with its first model", () => {
+ for (const provider of [
+ AISetting_Provider.OPEN_AI,
+ AISetting_Provider.AZURE_OPENAI,
+ AISetting_Provider.GEMINI,
+ AISetting_Provider.CLAUDE,
+ ]) {
+ expect(PROVIDER_DEFAULTS[provider].model).toBe(
+ PROVIDER_MODELS[provider][0].value
+ );
+ expect(PROVIDER_DEFAULTS[provider].endpoint).toBe(
+ PROVIDER_MODELS[provider][0].endpoint
+ );
+ }
+ });
+
+ test("uses the legacy Chat Completions API for GPT-4o", () => {
+ for (const provider of [
+ AISetting_Provider.OPEN_AI,
+ AISetting_Provider.AZURE_OPENAI,
+ ]) {
+ const gpt4o = PROVIDER_MODELS[provider].find(
+ (model) => model.value === "gpt-4o"
+ );
+ expect(gpt4o?.endpoint).toContain("/chat/completions");
+ }
+ });
+
+ test("preserves the Azure resource origin when changing models", () => {
+ const provider = AISetting_Provider.AZURE_OPENAI;
+ const gpt4o = PROVIDER_MODELS[provider].find(
+ (model) => model.value === "gpt-4o"
+ );
+ const gpt5 = PROVIDER_MODELS[provider].find(
+ (model) => model.value === "gpt-5"
+ );
+
+ expect(gpt4o).toBeDefined();
+ expect(gpt5).toBeDefined();
+ expect(
+ getModelEndpoint(provider, PROVIDER_DEFAULTS[provider].endpoint, gpt4o!)
+ ).toBe(gpt4o!.endpoint);
+ expect(
+ getModelEndpoint(
+ provider,
+ "https://{resource%20name}.openai.azure.com/openai/v1/responses",
+ gpt4o!
+ )
+ ).toBe(gpt4o!.endpoint);
+ expect(
+ getModelEndpoint(
+ provider,
+ "https://contoso.openai.azure.com/openai/v1/responses",
+ gpt4o!
+ )
+ ).toBe("https://contoso.openai.azure.com/openai/v1/chat/completions");
+ expect(
+ getModelEndpoint(
+ provider,
+ "https://contoso.openai.azure.com/openai/deployments/legacy/chat/completions?api-version=2024-06-01",
+ gpt5!
+ )
+ ).toBe("https://contoso.openai.azure.com/openai/v1/responses");
+ });
});
diff --git a/frontend/src/routes/workspace/general/aiProviderDefaults.ts b/frontend/src/routes/workspace/general/aiProviderDefaults.ts
index 1d82bbcef0..068efaeb37 100644
--- a/frontend/src/routes/workspace/general/aiProviderDefaults.ts
+++ b/frontend/src/routes/workspace/general/aiProviderDefaults.ts
@@ -1,24 +1,127 @@
import { AISetting_Provider } from "@/types/proto-es/v1/setting_service_pb";
+export interface ProviderModel {
+ endpoint: string;
+ value: string;
+}
+
+const OPENAI_RESPONSES_ENDPOINT = "https://api.openai.com/v1/responses";
+const OPENAI_CHAT_COMPLETIONS_ENDPOINT =
+ "https://api.openai.com/v1/chat/completions";
+const AZURE_OPENAI_RESPONSES_ENDPOINT =
+ "https://{resource name}.openai.azure.com/openai/v1/responses";
+const AZURE_OPENAI_CHAT_COMPLETIONS_ENDPOINT =
+ "https://{resource name}.openai.azure.com/openai/v1/chat/completions";
+
+export const PROVIDER_MODELS: Record<AISetting_Provider, ProviderModel[]> = {
+ [AISetting_Provider.OPEN_AI]: [
+ { value: "gpt-5.6-terra", endpoint: OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-6-astra", endpoint: OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5.6-sol", endpoint: OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5.6-luna", endpoint: OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5.5", endpoint: OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5", endpoint: OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5-mini", endpoint: OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-4o", endpoint: OPENAI_CHAT_COMPLETIONS_ENDPOINT },
+ ],
+ [AISetting_Provider.AZURE_OPENAI]: [
+ { value: "gpt-5.6-terra", endpoint: AZURE_OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-6-astra", endpoint: AZURE_OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5.6-sol", endpoint: AZURE_OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5.6-luna", endpoint: AZURE_OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5.5", endpoint: AZURE_OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5", endpoint: AZURE_OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-5-mini", endpoint: AZURE_OPENAI_RESPONSES_ENDPOINT },
+ { value: "gpt-4o", endpoint: AZURE_OPENAI_CHAT_COMPLETIONS_ENDPOINT },
+ ],
+ [AISetting_Provider.GEMINI]: [
+ {
+ value: "gemini-3.8-flash",
+ endpoint: "https://generativelanguage.googleapis.com/v1beta",
+ },
+ {
+ value: "gemini-3.7-flash",
+ endpoint: "https://generativelanguage.googleapis.com/v1beta",
+ },
+ {
+ value: "gemini-3.6-flash",
+ endpoint: "https://generativelanguage.googleapis.com/v1beta",
+ },
+ {
+ value: "gemini-3.5-flash",
+ endpoint: "https://generativelanguage.googleapis.com/v1beta",
+ },
+ {
+ value: "gemini-3.5-flash-lite",
+ endpoint: "https://generativelanguage.googleapis.com/v1beta",
+ },
+ ],
+ [AISetting_Provider.CLAUDE]: [
+ {
+ value: "claude-sonnet-5",
+ endpoint: "https://api.anthropic.com/v1/messages",
+ },
+ {
+ value: "claude-opus-5",
+ endpoint: "https://api.anthropic.com/v1/messages",
+ },
+ {
+ value: "claude-fable-5-1",
+ endpoint: "https://api.anthropic.com/v1/messages",
+ },
+ {
+ value: "claude-haiku-4-5",
+ endpoint: "https://api.anthropic.com/v1/messages",
+ },
+ ],
+ [AISetting_Provider.PROVIDER_UNSPECIFIED]: [],
+};
+
+export function getModelEndpoint(
+ provider: AISetting_Provider,
+ currentEndpoint: string,
+ model: ProviderModel
+): string {
+ if (provider !== AISetting_Provider.AZURE_OPENAI) {
+ return model.endpoint;
+ }
+ if (
+ currentEndpoint.includes("{resource name}") ||
+ currentEndpoint.includes("{resource%20name}")
+ ) {
+ return model.endpoint;
+ }
+ try {
+ const endpoint = new URL(currentEndpoint);
+ const modelEndpoint = new URL(
+ model.endpoint.replace("{resource name}", "resource")
+ );
+ endpoint.pathname = modelEndpoint.pathname;
+ endpoint.search = modelEndpoint.search;
+ return endpoint.toString();
+ } catch {
+ return model.endpoint;
+ }
+}
+
export const PROVIDER_DEFAULTS: Record<
AISetting_Provider,
{ apiKeyDoc: string; endpoint: string; model: string }
> = {
[AISetting_Provider.OPEN_AI]: {
apiKeyDoc: "https://platform.openai.com/account/api-keys",
- endpoint: "https://api.openai.com/v1/chat/completions",
- model: "gpt-5.5",
+ endpoint: OPENAI_RESPONSES_ENDPOINT,
+ model: "gpt-5.6-terra",
},
[AISetting_Provider.AZURE_OPENAI]: {
apiKeyDoc: "https://ai.azure.com/",
- endpoint:
- "https://{resource name}.openai.azure.com/openai/deployments/{deployment id}/chat/completions?api-version=2024-06-01",
- model: "gpt-5.5",
+ endpoint: AZURE_OPENAI_RESPONSES_ENDPOINT,
+ model: "gpt-5.6-terra",
},
[AISetting_Provider.GEMINI]: {
apiKeyDoc: "https://ai.google.dev/gemini-api/docs",
endpoint: "https://generativelanguage.googleapis.com/v1beta",
- model: "gemini-3.5-flash",
+ model: "gemini-3.8-flash",
},
[AISetting_Provider.CLAUDE]: {
apiKeyDoc: "https://docs.anthropic.com/en/api/getting-started",