jianf/HomeAgent
1
0
Fork 0
mirror of https://gitcode.com/JianFeeeee/HomeAgent.git synced 2026-09-22 18:08:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

适配多个 LLM 源 (anthropic/gemini/mistral/groq/github) + SQLite 配置收敛 + 测试插件

Browse Source
This commit is contained in:
root
2026-07-03 14:03:51 +08:00
parent b1b90ae09f
commit 4442c9cea4
16 changed files with 2059 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
internal/plugins/test_deepseek/plugin.go Normal file
View File

@ -0,0 +1,129 @@
package test_deepseek
import (
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
"time"
sdk "gitcode.com/JianFeeeee/HomeAgent/internal/plugin/sdk"
)
var defaultClient = &http.Client{Timeout: 30 * time.Second}
func New(bus sdk.EventBus) *sdk.PluginAPI {
api := sdk.NewPluginAPI("test_deepseek", "1.0.0", bus, nil, nil)
api.RegisterTool("test_deepseek", func(args map[string]interface{}) (interface{}, error) {
prompt, _ := args["prompt"].(string)
if prompt == "" {
prompt = "你好，请用一句话介绍你自己"
}
return callDeepSeek(prompt, api.Settings(), defaultClient)
})
return api
}
func callDeepSeek(prompt string, sett sdk.SettingsAPI, client *http.Client) (interface{}, error) {
baseURL := "https://api.deepseek.com/v1"
model := "deepseek-chat"
apiKey := ""
if sett != nil {
if v, err := sett.Get("base_url"); err == nil {
if s, ok := v.(string); ok && s != "" {
baseURL = s
}
}
if v, err := sett.Get("model"); err == nil {
if s, ok := v.(string); ok && s != "" {
model = s
}
}
if v, err := sett.Get("api_key"); err == nil {
if s, ok := v.(string); ok && s != "" {
apiKey = s
}
}
}
if apiKey == "" {
apiKey = "sk-feaa590161ed404b956f941992fae6f0"
}
body := map[string]interface{}{
"model": model,
"messages": []map[string]string{
{"role": "user", "content": prompt},
},
"temperature": 0.7,
"max_tokens": 1024,
"stream": false,
}
bodyJSON, _ := json.Marshal(body)
req, err := http.NewRequest("POST", strings.TrimRight(baseURL, "/")+"/chat/completions", strings.NewReader(string(bodyJSON)))
if err != nil {
return map[string]interface{}{"error": fmt.Sprintf("创建请求失败: %v", err)}, nil
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, err := client.Do(req)
if err != nil {
return map[string]interface{}{"error": fmt.Sprintf("API 调用失败: %v", err)}, nil
}
defer resp.Body.Close()
respBody, _ := io.ReadAll(resp.Body)
if resp.StatusCode != 200 {
return map[string]interface{}{
"error": fmt.Sprintf("API 返回 %d", resp.StatusCode),
"body": string(respBody),
"status": "failed",
}, nil
}
var result struct {
Choices []struct {
Message struct {
Content string `json:"content"`
} `json:"message"`
} `json:"choices"`
Usage struct {
PromptTokens int `json:"prompt_tokens"`
CompletionTokens int `json:"completion_tokens"`
TotalTokens int `json:"total_tokens"`
} `json:"usage"`
}
if err := json.Unmarshal(respBody, &result); err != nil {
return map[string]interface{}{"error": fmt.Sprintf("解析响应失败: %v", err)}, nil
}
content := ""
if len(result.Choices) > 0 {
content = result.Choices[0].Message.Content
}
return map[string]interface{}{
"prompt": prompt,
"response": content,
"model": model,
"usage": result.Usage,
"status": "ok",
"base_url": baseURL,
}, nil
}
func NewWithClient(bus sdk.EventBus, client *http.Client) *sdk.PluginAPI {
api := sdk.NewPluginAPI("test_deepseek", "1.0.0", bus, nil, nil)
api.RegisterTool("test_deepseek", func(args map[string]interface{}) (interface{}, error) {
prompt, _ := args["prompt"].(string)
if prompt == "" {
prompt = "你好，请用一句话介绍你自己"
}
return callDeepSeek(prompt, api.Settings(), client)
})
return api
}

246
internal/plugins/test_deepseek/plugin_test.go Normal file
View File

@ -0,0 +1,246 @@
package test_deepseek
import (
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
sdk "gitcode.com/JianFeeeee/HomeAgent/internal/plugin/sdk"
)
type mockSettings struct {
data map[string]string
}
func (m *mockSettings) Get(key string) (interface{}, error) {
v, ok := m.data[key]
if !ok {
return nil, nil
}
return v, nil
}
func (m *mockSettings) Set(key string, value interface{}) error {
m.data[key] = value.(string)
return nil
}
func (m *mockSettings) List(prefix string) ([]string, error) {
var keys []string
for k := range m.data {
keys = append(keys, k)
}
return keys, nil
}
func mockAPI(t *testing.T) *httptest.Server {
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
t.Fatalf("expected POST, got %s", r.Method)
}
if r.Header.Get("Authorization") != "Bearer sk-test123" {
t.Fatalf("expected Bearer sk-test123, got %s", r.Header.Get("Authorization"))
}
if r.Header.Get("Content-Type") != "application/json" {
t.Fatalf("expected application/json, got %s", r.Header.Get("Content-Type"))
}
var reqBody map[string]interface{}
json.NewDecoder(r.Body).Decode(&reqBody)
if reqBody["model"] != "test-model" {
t.Fatalf("expected test-model, got %v", reqBody["model"])
}
if reqBody["stream"] != false {
t.Fatalf("expected stream=false, got %v", reqBody["stream"])
}
w.WriteHeader(200)
json.NewEncoder(w).Encode(map[string]interface{}{
"choices": []map[string]interface{}{
{
"message": map[string]string{
"content": "你好！我是 DeepSeek。",
},
},
},
"usage": map[string]int{
"prompt_tokens": 10,
"completion_tokens": 20,
"total_tokens": 30,
},
})
}))
}
func TestCallDeepSeekSuccess(t *testing.T) {
ts := mockAPI(t)
defer ts.Close()
sett := &mockSettings{data: map[string]string{
"base_url": ts.URL,
"model": "test-model",
"api_key": "sk-test123",
}}
result, err := callDeepSeek("你好", sett, ts.Client())
if err != nil {
t.Fatalf("callDeepSeek: %v", err)
}
// 通过 JSON 反序列化验证（避免匿名 struct 类型断言问题）
data, _ := json.Marshal(result)
var resp map[string]interface{}
json.Unmarshal(data, &resp)
if resp["status"] != "ok" {
t.Fatalf("expected status ok, got %v", resp["status"])
}
if resp["response"] != "你好！我是 DeepSeek。" {
t.Fatalf("expected response 你好！我是 DeepSeek。, got %v", resp["response"])
}
if resp["model"] != "test-model" {
t.Fatalf("expected model test-model, got %v", resp["model"])
}
usage := resp["usage"].(map[string]interface{})
if usage["total_tokens"].(float64) != 30 {
t.Fatalf("expected 30 total tokens, got %v", usage["total_tokens"])
}
}
func TestCallDeepSeekNon200(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(401)
w.Write([]byte(`{"error":"unauthorized"}`))
}))
defer ts.Close()
sett := &mockSettings{data: map[string]string{
"base_url": ts.URL,
"model": "test-model",
"api_key": "sk-bad",
}}
result, err := callDeepSeek("hi", sett, ts.Client())
if err != nil {
t.Fatalf("callDeepSeek: %v", err)
}
m := result.(map[string]interface{})
if m["status"] != "failed" {
t.Fatalf("expected status failed, got %v", m["status"])
}
}
func TestCallDeepSeekDefaultPrompt(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var reqBody map[string]interface{}
json.NewDecoder(r.Body).Decode(&reqBody)
msgs := reqBody["messages"].([]interface{})
msg := msgs[0].(map[string]interface{})
if msg["content"] == "你好，请用一句话介绍你自己" {
w.WriteHeader(200)
json.NewEncoder(w).Encode(map[string]interface{}{
"choices": []map[string]interface{}{
{"message": map[string]string{"content": "ok"}},
},
})
return
}
t.Fatalf("unexpected prompt: %v", msg["content"])
}))
defer ts.Close()
sett := &mockSettings{data: map[string]string{
"base_url": ts.URL,
"model": "test-model",
"api_key": "sk-test",
}}
bus := sdk.NewInProcessBus()
api := NewWithClient(bus, ts.Client())
api.SetSettings(sett)
handler := api.Tools()["test_deepseek"]
result, err := handler(map[string]interface{}{})
if err != nil {
t.Fatalf("handler: %v", err)
}
data, _ := json.Marshal(result)
var resp map[string]interface{}
json.Unmarshal(data, &resp)
if resp["status"] != "ok" {
t.Fatalf("expected ok, got %v", resp["status"])
}
}
func TestCallDeepSeekFallbackAPIKey(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
expected := "Bearer sk-feaa590161ed404b956f941992fae6f0"
if r.Header.Get("Authorization") != expected {
t.Fatalf("expected %s, got %s", expected, r.Header.Get("Authorization"))
}
w.WriteHeader(200)
json.NewEncoder(w).Encode(map[string]interface{}{
"choices": []map[string]interface{}{
{"message": map[string]string{"content": "ok"}},
},
})
}))
defer ts.Close()
// 不设 api_key 触发 fallback
sett := &mockSettings{data: map[string]string{
"base_url": ts.URL,
"model": "test-model",
}}
result, err := callDeepSeek("hi", sett, ts.Client())
if err != nil {
t.Fatalf("callDeepSeek: %v", err)
}
m := result.(map[string]interface{})
if m["status"] != "ok" {
t.Fatalf("expected ok, got %v", m["status"])
}
}
func TestNewWithClient(t *testing.T) {
ts := mockAPI(t)
defer ts.Close()
sett := &mockSettings{data: map[string]string{
"base_url": ts.URL,
"model": "test-model",
"api_key": "sk-test123",
}}
bus := sdk.NewInProcessBus()
api := NewWithClient(bus, ts.Client())
api.SetSettings(sett)
handler := api.Tools()["test_deepseek"]
if handler == nil {
t.Fatal("test_deepseek tool not registered")
}
result, err := handler(map[string]interface{}{"prompt": "你好"})
if err != nil {
t.Fatalf("tool handler: %v", err)
}
m := result.(map[string]interface{})
if m["status"] != "ok" {
t.Fatalf("expected ok, got %v", m["status"])
}
if m["response"] != "你好！我是 DeepSeek。" {
t.Fatalf("expected response, got %v", m["response"])
}
}
func TestNewDefaultClient(t *testing.T) {
bus := sdk.NewInProcessBus()
api := New(bus)
if api == nil {
t.Fatal("New returned nil")
}
if api.Name != "test_deepseek" {
t.Fatalf("expected name test_deepseek, got %s", api.Name)
}
tools := api.Tools()
if _, ok := tools["test_deepseek"]; !ok {
t.Fatal("test_deepseek tool not registered")
}
}