RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
//
// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package models
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"mime/multipart"
"net/http"
"net/url"
"ragflow/internal/common"
"strings"
"time"
)
// GiteeModel implements ModelDriver for Gitee
type GiteeModel struct {
baseModel BaseModel
}
// NewGiteeModel creates a new Gitee model instance
func NewGiteeModel(baseURL map[string]string, urlSuffix URLSuffix) *GiteeModel {
return &GiteeModel{
baseModel: BaseModel{
BaseURL: baseURL,
URLSuffix: urlSuffix,
httpClient: common.GetSSRFHTTPClient(),
},
}
}
func (g *GiteeModel) NewInstance(baseURL map[string]string) ModelDriver {
return NewGiteeModel(baseURL, g.baseModel.URLSuffix)
}
func (g *GiteeModel) Name() string {
return "GiteeAI"
}
// ChatWithMessages sends multiple messages with roles and returns response
func (g *GiteeModel) ChatWithMessages(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage) (*ChatResponse, error) {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return nil, err
}
if len(messages) == 0 {
return nil, fmt.Errorf("messages is empty")
}
url, err := g.baseModel.EndpointURL(apiConfig, g.baseModel.URLSuffix.Chat)
if err != nil {
return nil, err
}
reqBody := buildRequestBody(chatModelConfig, modelName, messages, false)
if chatModelConfig != nil {
if chatModelConfig.Thinking != nil {
if *chatModelConfig.Thinking {
reqBody["thinking"] = map[string]interface{}{
"type": "enabled",
}
} else {
reqBody["thinking"] = map[string]interface{}{
"type": "disabled",
}
}
}
}
body, err := g.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)
if err != nil {
return nil, err
}
return HandleNonStreamingResponse(ctx, body, modelUsage, chatModelConfig, OpenAIParserConfig)
}
// ChatStreamlyWithSender sends messages and streams response via sender function (best performance, no channel)
func (g *GiteeModel) ChatStreamlyWithSender(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage, sender func(*string, *string) error) error {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return err
}
if len(messages) == 0 {
return fmt.Errorf("messages is empty")
}
if chatModelConfig != nil {
chatModelConfig.ToolCallsResult = nil
chatModelConfig.UsageResult = nil
}
url, err := g.baseModel.EndpointURL(apiConfig, g.baseModel.URLSuffix.Chat)
if err != nil {
return err
}
reqBody := buildRequestBody(chatModelConfig, modelName, messages, true)
reqBody["stream_options"] = map[string]any{"include_usage": true}
if chatModelConfig != nil {
if chatModelConfig.Thinking != nil {
if *chatModelConfig.Thinking {
reqBody["thinking"] = map[string]interface{}{
"type": "enabled",
}
} else {
reqBody["thinking"] = map[string]interface{}{
"type": "disabled",
}
}
}
}
return g.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {
return HandleStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig, sender)
})
}
// GiteeEmbeddingResponse mirrors GiteeAI's embeddings response.
type GiteeEmbeddingResponse struct {
ID string `json:"id"`
Object string `json:"object"`
Model string `json:"model"`
Data []struct {
Object string `json:"object"`
Embedding []float64 `json:"embedding"`
Index int `json:"index"`
} `json:"data"`
Usage struct {
PromptTokens int `json:"prompt_tokens"`
CompletionTokens int `json:"completion_tokens"`
TotalTokens int `json:"total_tokens"`
} `json:"usage"`
}
// Embed embeds a list of texts into embeddings
func (g *GiteeModel) Embed(ctx context.Context, modelName *string, request EmbedRequest, apiConfig *APIConfig, embeddingConfig *EmbeddingConfig, modelUsage *common.ModelUsage) ([]EmbeddingData, error) {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return nil, err
}
if len(request.Texts) == 0 {
return []EmbeddingData{}, nil
}
if modelName == nil || *modelName == "" {
return nil, fmt.Errorf("model name is required")
}
resolvedBaseURL, err := g.baseModel.GetBaseURL(apiConfig)
if err != nil {
return nil, err
}
baseURL := resolvedBaseURL
url := joinURL(baseURL, g.baseModel.URLSuffix.Embedding)
reqBody := map[string]interface{}{
"model": *modelName,
"input": request.Texts,
}
if embeddingConfig != nil && embeddingConfig.Dimension > 0 {
reqBody["dimensions"] = embeddingConfig.Dimension
}
jsonData, err := json.Marshal(reqBody)
if err != nil {
return nil, fmt.Errorf("failed to marshal request: %w", err)
}
ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("Gitee embeddings API error: %s, body: %s", resp.Status, string(body))
}
var parsed GiteeEmbeddingResponse
if err = json.Unmarshal(body, &parsed); err != nil {
return nil, fmt.Errorf("failed to parse response: %w", err)
}
recordResponseUsage(modelUsage, parsed.ID, &TokenUsage{
PromptTokens: parsed.Usage.PromptTokens,
CompletionTokens: parsed.Usage.CompletionTokens,
TotalTokens: parsed.Usage.TotalTokens,
}, "embedding")
var embeddings []EmbeddingData
for _, dataElem := range parsed.Data {
var embeddingData EmbeddingData
embeddingData.Embedding = dataElem.Embedding
embeddingData.Index = dataElem.Index
embeddings = append(embeddings, embeddingData)
}
return embeddings, nil
}
type giteeRerankRequest struct {
Model string `json:"model"`
Query string `json:"query"`
Documents []string `json:"documents"`
TopN int `json:"top_n"`
ReturnDocuments bool `json:"return_documents"`
}
// GiteeRerankResponse mirrors GiteeAI's rerank response.
type GiteeRerankResponse struct {
ID string `json:"id"`
Model string `json:"model"`
Results []struct {
Index int `json:"index"`
Document struct {
Text string `json:"text"`
} `json:"document"`
RelevanceScore float64 `json:"relevance_score"`
} `json:"results"`
Usage struct {
PromptTokens int `json:"prompt_tokens"`
CompletionTokens int `json:"completion_tokens"`
TotalTokens int `json:"total_tokens"`
} `json:"usage"`
}
// Rerank calculates similarity scores between query and documents
func (g *GiteeModel) Rerank(ctx context.Context, modelName *string, request RerankRequest, apiConfig *APIConfig, rerankConfig *RerankConfig, modelUsage *common.ModelUsage) (*RerankResponse, error) {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return nil, err
}
documents := request.Documents
query := request.Query
if len(documents) == 0 {
return &RerankResponse{}, nil
}
if modelName == nil || *modelName == "" {
return nil, fmt.Errorf("model name is required")
}
resolvedBaseURL, err := g.baseModel.GetBaseURL(apiConfig)
if err != nil {
return nil, err
}
baseURL := resolvedBaseURL
url := joinURL(baseURL, g.baseModel.URLSuffix.Rerank)
topN := len(documents)
if rerankConfig != nil && rerankConfig.TopN > 0 {
topN = rerankConfig.TopN
}
reqBody := giteeRerankRequest{
Model: *modelName,
Query: query,
Documents: documents,
TopN: topN,
ReturnDocuments: false,
}
jsonData, err := json.Marshal(reqBody)
if err != nil {
return nil, fmt.Errorf("failed to marshal request: %w", err)
}
ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("gitee rerank API error: %s, body: %s", resp.Status, string(body))
}
var parsed GiteeRerankResponse
if err = json.Unmarshal(body, &parsed); err != nil {
return nil, fmt.Errorf("failed to parse response: %w", err)
}
recordResponseUsage(modelUsage, parsed.ID, &TokenUsage{
PromptTokens: parsed.Usage.PromptTokens,
CompletionTokens: parsed.Usage.CompletionTokens,
TotalTokens: parsed.Usage.TotalTokens,
}, "rerank")
rerankResponse := RerankResponse{Data: make([]RerankResult, 0, len(parsed.Results))}
for _, result := range parsed.Results {
rerankResponse.Data = append(rerankResponse.Data, RerankResult{
Index: result.Index,
RelevanceScore: result.RelevanceScore,
})
}
return &rerankResponse, nil
}
// TranscribeAudio transcribe audio
func (g *GiteeModel) TranscribeAudio(ctx context.Context, modelName *string, file *string, apiConfig *APIConfig, asrConfig *ASRConfig, modelUsage *common.ModelUsage) (*ASRResponse, error) {
return nil, fmt.Errorf("%s: no such method: TranscribeAudio", g.Name())
}
func (g *GiteeModel) TranscribeAudioWithSender(ctx context.Context, modelName *string, file *string, apiConfig *APIConfig, asrConfig *ASRConfig, modelUsage *common.ModelUsage, sender func(*string, *string) error) error {
return fmt.Errorf("%s: no such method: TranscribeAudioWithSender", g.Name())
}
// AudioSpeech convert text to audio
func (g *GiteeModel) AudioSpeech(ctx context.Context, modelName *string, audioContent *string, apiConfig *APIConfig, ttsConfig *TTSConfig, modelUsage *common.ModelUsage) (*TTSResponse, error) {
return nil, fmt.Errorf("%s: no such method: AudioSpeech", g.Name())
}
func (g *GiteeModel) AudioSpeechWithSender(ctx context.Context, modelName *string, audioContent *string, apiConfig *APIConfig, ttsConfig *TTSConfig, modelUsage *common.ModelUsage, sender func(*string, *string) error) error {
return fmt.Errorf("%s: no such method: AudioSpeechWithSender", g.Name())
}
type giteeOCRResponse struct {
Text string `json:"text_result"`
Prompt string `json:"prompt"`
}
// OCRFile OCR file
func (g *GiteeModel) OCRFile(ctx context.Context, modelName *string, content []byte, imageURL *string, apiConfig *APIConfig, ocrConfig *OCRConfig, modelUsage *common.ModelUsage) (*OCRFileResponse, error) {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return nil, err
}
if imageURL == nil && content == nil {
return nil, fmt.Errorf("url or content is required")
}
if modelName == nil || *modelName == "" {
return nil, fmt.Errorf("model name is required")
}
resolvedBaseURL, err := g.baseModel.GetBaseURL(apiConfig)
if err != nil {
return nil, err
}
baseURL := resolvedBaseURL
url := joinURL(baseURL, g.baseModel.URLSuffix.OCR)
payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
if err = writer.WriteField("model", *modelName); err != nil {
return nil, fmt.Errorf("failed to write model field: %w", err)
}
if imageURL != nil {
if err = writer.WriteField("image", *imageURL); err != nil {
return nil, fmt.Errorf("failed to write image URL: %w", err)
}
} else if content != nil && len(content) > 0 {
part, err := writer.CreateFormFile("image", "image")
if err != nil {
return nil, fmt.Errorf("failed to create image form file: %w", err)
}
if _, err = part.Write(content); err != nil {
return nil, fmt.Errorf("failed to write image content: %w", err)
}
} else {
return nil, fmt.Errorf("image or image URL is required")
}
writer.Close()
ctx, cancel := context.WithTimeout(ctx, longOpCallTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, "POST", url, payload)
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", writer.FormDataContentType())
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("gitee OCR API error: %s, body: %s", resp.Status, string(body))
}
var giteeResponse giteeOCRResponse
if err = json.Unmarshal(body, &giteeResponse); err != nil {
return nil, fmt.Errorf("failed to parse response: %w", err)
}
var ocrResponse = OCRFileResponse{
Text: &giteeResponse.Text,
}
return &ocrResponse, nil
}
type giteeParseFileResponse struct {
TaskID string `json:"task_id"`
Status string `json:"status"`
CreatedAt int64 `json:"created_at"`
URLs giteeURLs `json:"urls"`
}
type giteeURLs struct {
Get string `json:"get"`
Cancel string `json:"cancel"`
}
// ParseFile parse file
func (g *GiteeModel) ParseFile(ctx context.Context, modelName *string, content []byte, documentURL *string, apiConfig *APIConfig, parseFileConfig *ParseFileConfig, modelUsage *common.ModelUsage) (*ParseFileResponse, error) {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return nil, err
}
if documentURL == nil && content == nil {
return nil, fmt.Errorf("url or content is required")
}
if modelName == nil || *modelName == "" {
return nil, fmt.Errorf("model name is required")
}
resolvedBaseURL, err := g.baseModel.GetBaseURL(apiConfig)
if err != nil {
return nil, err
}
baseURL := resolvedBaseURL
url := joinURL(baseURL, g.baseModel.URLSuffix.DocumentParse)
payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
if err = writer.WriteField("model", *modelName); err != nil {
return nil, fmt.Errorf("failed to write model field: %w", err)
}
if documentURL != nil {
if err = writer.WriteField("file", *documentURL); err != nil {
return nil, fmt.Errorf("failed to write file URL: %w", err)
}
} else if content != nil && len(content) > 0 {
part, err := writer.CreateFormFile("file", "file")
if err != nil {
return nil, fmt.Errorf("failed to create file form file: %w", err)
}
if _, err = part.Write(content); err != nil {
return nil, fmt.Errorf("failed to write file content: %w", err)
}
} else {
return nil, fmt.Errorf("file or file URL is required")
}
writer.Close()
ctx, cancel := context.WithTimeout(ctx, longOpCallTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, "POST", url, payload)
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", writer.FormDataContentType())
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("gitee OCR API error: %s, body: %s", resp.Status, string(body))
}
var giteeParseFileResp giteeParseFileResponse
if err = json.Unmarshal(body, &giteeParseFileResp); err != nil {
return nil, fmt.Errorf("failed to parse response: %w", err)
}
if strings.TrimSpace(giteeParseFileResp.TaskID) == "" {
return nil, fmt.Errorf("Gitee parse API response is missing task_id")
}
_, err = g.getParseFile(ctx, &baseURL, apiConfig.ApiKey, &giteeParseFileResp.TaskID, 5*time.Second, 10)
if err != nil {
return nil, err
}
return &ParseFileResponse{TaskID: giteeParseFileResp.TaskID}, nil
}
type giteeGetParseFileResponse struct {
Status string `json:"status"`
}
func (g *GiteeModel) getParseFile(ctx context.Context, baseURL *string, apiKey, taskID *string, pollInterval time.Duration, maxPolls int) (*giteeGetParseFileResponse, error) {
if baseURL == nil || strings.TrimSpace(*baseURL) == "" {
return nil, fmt.Errorf("Gitee base URL is required")
}
if apiKey == nil || strings.TrimSpace(*apiKey) == "" {
return nil, fmt.Errorf("Gitee API key is required")
}
if taskID == nil || strings.TrimSpace(*taskID) == "" {
return nil, fmt.Errorf("Gitee task ID is required")
}
if maxPolls <= 0 {
return nil, fmt.Errorf("Gitee parse task polling count must be positive")
}
statusURL := fmt.Sprintf("%s/task/%s/status", strings.TrimRight(strings.TrimSpace(*baseURL), "/"), url.PathEscape(strings.TrimSpace(*taskID)))
ctx, cancel := context.WithTimeout(ctx, longOpCallTimeout)
defer cancel()
for i := 0; i < maxPolls; i++ {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, statusURL, nil)
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", strings.TrimSpace(*apiKey)))
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
body, err := io.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
return nil, fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
}
var result giteeGetParseFileResponse
if err = json.Unmarshal(body, &result); err != nil {
return nil, fmt.Errorf("failed to parse response: %w", err)
}
switch status := strings.ToLower(strings.TrimSpace(result.Status)); status {
case "success":
return &result, nil
case "failure", "cancelled":
return nil, fmt.Errorf("Gitee parse task %s: %s", strings.TrimSpace(*taskID), status)
case "waiting", "in_progress":
default:
return nil, fmt.Errorf("Gitee parse task %s returned unknown status %q", strings.TrimSpace(*taskID), result.Status)
}
if i+1 < maxPolls && pollInterval > 0 {
timer := time.NewTimer(pollInterval)
select {
case <-ctx.Done():
timer.Stop()
return nil, ctx.Err()
case <-timer.C:
}
}
}
return nil, fmt.Errorf("timed out waiting for Gitee parse task %s after %d polls", strings.TrimSpace(*taskID), maxPolls)
}
func (g *GiteeModel) ListModels(ctx context.Context, apiConfig *APIConfig) ([]ListModelResponse, error) {
url, err := g.baseModel.EndpointURL(apiConfig, g.baseModel.URLSuffix.Models)
if err != nil {
return nil, err
}
// Build request body
reqBody := map[string]interface{}{}
jsonData, err := json.Marshal(reqBody)
if err != nil {
return nil, fmt.Errorf("failed to marshal request: %w", err)
}
ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, "GET", url, bytes.NewBuffer(jsonData))
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
}
// Parse response
var modelList ModelList
if err = json.Unmarshal(body, &modelList); err != nil {
return nil, fmt.Errorf("failed to parse response: %w", err)
}
return ParseListModel(modelList), nil
}
func (g *GiteeModel) Balance(ctx context.Context, apiConfig *APIConfig) (map[string]interface{}, error) {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return nil, err
}
url, err := g.baseModel.EndpointURL(apiConfig, g.baseModel.URLSuffix.Balance)
if err != nil {
return nil, err
}
// Build request body
reqBody := map[string]interface{}{}
jsonData, err := json.Marshal(reqBody)
if err != nil {
return nil, fmt.Errorf("failed to marshal request: %w", err)
}
ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, "GET", url, bytes.NewBuffer(jsonData))
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
}
// Parse response
var result struct {
Balance *float64 `json:"balance"`
}
if err = json.Unmarshal(body, &result); err != nil {
return nil, fmt.Errorf("failed to parse response: %w", err)
}
if result.Balance == nil {
return nil, fmt.Errorf("invalid balance response: balance must be a number")
}
var response = map[string]interface{}{
"balance": *result.Balance,
"currency": "CNY",
}
return response, nil
}
func (g *GiteeModel) CheckConnection(ctx context.Context, apiConfig *APIConfig) error {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return err
}
url, err := g.baseModel.EndpointURL(apiConfig, g.baseModel.URLSuffix.Status)
if err != nil {
return err
}
// Build request body
reqBody := map[string]interface{}{}
jsonData, err := json.Marshal(reqBody)
if err != nil {
return fmt.Errorf("failed to marshal request: %w", err)
}
ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, "GET", url, bytes.NewBuffer(jsonData))
if err != nil {
return fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
}
return nil
}
type giteeTaskListResponse struct {
Total int `json:"total"`
Items []giteeTaskItem `json:"items"`
}
type giteeTaskItem struct {
TaskID string `json:"task_id"`
Output giteeTaskOutput `json:"output"`
Status string `json:"status"`
CreatedAt int64 `json:"created_at"`
StartedAt int64 `json:"started_at,omitempty"`
CompletedAt int64 `json:"completed_at,omitempty"`
Price float64 `json:"price"`
Currency string `json:"currency"`
URLs giteeTaskURLs `json:"urls"`
}
type giteeTaskOutput struct {
Segments []giteeSegment `json:"segments"`
}
type giteeSegment struct {
Index int `json:"index"`
Content string `json:"content"`
}
type giteeTaskURLs struct {
Get string `json:"get"`
Cancel string `json:"cancel"`
}
func (g *GiteeModel) ListTasks(ctx context.Context, apiConfig *APIConfig) ([]ListTaskStatus, error) {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return nil, err
}
url, err := g.baseModel.EndpointURL(apiConfig, g.baseModel.URLSuffix.Tasks)
if err != nil {
return nil, err
}
// Build request body
reqBody := map[string]interface{}{}
jsonData, err := json.Marshal(reqBody)
if err != nil {
return nil, fmt.Errorf("failed to marshal request: %w", err)
}
ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, "GET", url, bytes.NewBuffer(jsonData))
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
var body []byte
body, err = io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("failed to read response: %w", err)
}
var giteeTaskList giteeTaskListResponse
if err = json.Unmarshal(body, &giteeTaskList); err != nil {
return nil, fmt.Errorf("failed to parse response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
}
var taskListResp []ListTaskStatus
for _, item := range giteeTaskList.Items {
taskListResp = append(taskListResp, ListTaskStatus{
TaskID: item.TaskID,
Status: item.Status,
})
}
return taskListResp, nil
}
func (g *GiteeModel) ShowTask(ctx context.Context, taskID string, apiConfig *APIConfig) (*TaskResponse, error) {
if err := g.baseModel.APIConfigCheck(apiConfig); err != nil {
return nil, err
}
taskID = strings.TrimSpace(taskID)
if taskID == "" {
return nil, fmt.Errorf("Gitee task ID is required")
}
taskURL, err := g.baseModel.EndpointURL(apiConfig, g.baseModel.URLSuffix.Task)
if err != nil {
return nil, err
}
taskRecordURL := taskURL + "/" + url.PathEscape(taskID)
ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, taskRecordURL, nil)
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
resp, err := g.baseModel.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
}
var taskRecord giteeTaskItem
if err = json.Unmarshal(body, &taskRecord); err != nil {
return nil, fmt.Errorf("failed to parse response: %w", err)
}
if strings.ToLower(strings.TrimSpace(taskRecord.Status)) != "success" {
return nil, fmt.Errorf("Gitee parse task %s is not successful: status %q", taskID, taskRecord.Status)
}
taskResp := &TaskResponse{}
for _, segment := range taskRecord.Output.Segments {
taskResp.Segments = append(taskResp.Segments, TaskSegment{
Index: segment.Index,
Content: segment.Content,
})
}
return taskResp, nil
}
func (g *GiteeModel) Decide(ctx context.Context, modelName *string, request *DecideRequest, apiConfig *APIConfig, modelUsage *common.ModelUsage) (*DecideResponse, error) {
return nil, fmt.Errorf("%s: no such method: Decide", g.Name())
}