first commit

.dockerignore

@@ -0,0 +1,7 @@
+.git
+.gitignore
+README.md
+Dockerfile
+docker-compose.yml
+*.md
+.env 

.gitignore

@@ -0,0 +1,32 @@
+# 二进制文件
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+main
+
+# 测试文件
+*.test
+*.tmp
+
+# 输出文件
+*.out
+
+# 依赖目录
+/vendor/
+
+# IDE 相关
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# 环境变量文件
+.env
+
+# 日志文件
+*.log
+
+# macOS 系统文件
+.DS_Store 

Dockerfile

@@ -0,0 +1,41 @@
+# 使用官方 Go 镜像作为构建环境
+FROM golang:1.21-alpine AS builder
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制 go.mod 和 go.sum
+COPY go.mod go.sum ./
+
+# 下载依赖
+RUN go mod download
+
+# 复制源代码
+COPY . .
+
+# 构建应用
+RUN CGO_ENABLED=0 GOOS=linux go build -o main .
+
+# 使用轻量级的 alpine 作为运行环境
+FROM alpine:latest
+
+# 安装 ca-certificates
+RUN apk --no-cache add ca-certificates
+
+WORKDIR /root/
+
+# 从构建阶段复制二进制文件
+COPY --from=builder /app/main .
+
+# 设置环境变量
+ENV PORT=8080
+ENV ENABLE_PROXY=false
+ENV PROXY_URL=""
+ENV PROXY_TIMEOUT_MS=5000
+ENV LOG_LEVEL=info
+
+# 暴露端口
+EXPOSE 8080
+
+# 运行应用
+CMD ["./main"] 

README.md

@@ -0,0 +1,2 @@
+懂得都懂  
+自己研究

api/main.go

@@ -0,0 +1,330 @@
+package handler
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type YouChatResponse struct {
+	YouChatToken string `json:"youChatToken"`
+}
+
+type OpenAIStreamResponse struct {
+	ID      string   `json:"id"`
+	Object  string   `json:"object"`
+	Created int64    `json:"created"`
+	Model   string   `json:"model"`
+	Choices []Choice `json:"choices"`
+}
+
+type Choice struct {
+	Delta        Delta  `json:"delta"`
+	Index        int    `json:"index"`
+	FinishReason string `json:"finish_reason"`
+}
+
+type Delta struct {
+	Content string `json:"content"`
+}
+
+type OpenAIRequest struct {
+	Messages []Message `json:"messages"`
+	Stream   bool      `json:"stream"`
+	Model    string    `json:"model"`
+}
+
+type Message struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type OpenAIResponse struct {
+	ID      string         `json:"id"`
+	Object  string         `json:"object"`
+	Created int64          `json:"created"`
+	Model   string         `json:"model"`
+	Choices []OpenAIChoice `json:"choices"`
+}
+
+type OpenAIChoice struct {
+	Message      Message `json:"message"`
+	Index        int     `json:"index"`
+	FinishReason string  `json:"finish_reason"`
+}
+
+var modelMap = map[string]string{
+	"deepseek-reasoner":  "deepseek_r1",
+	"deepseek-chat":      "deepseek_v3",
+	"o3-mini-high":       "openai_o3_mini_high",
+	"o3-mini-medium":     "openai_o3_mini_medium",
+	"o1":                 "openai_o1",
+	"o1-mini":            "openai_o1_mini",
+	"o1-preview":         "openai_o1_preview",
+	"gpt-4o":             "gpt_4o",
+	"gpt-4o-mini":        "gpt_4o_mini",
+	"gpt-4-turbo":        "gpt_4_turbo",
+	"gpt-3.5-turbo":      "gpt_3.5",
+	"claude-3-opus":      "claude_3_opus",
+	"claude-3-sonnet":    "claude_3_sonnet",
+	"claude-3.5-sonnet":  "claude_3_5_sonnet",
+	"claude-3.5-haiku":   "claude_3_5_haiku",
+	"gemini-1.5-pro":     "gemini_1_5_pro",
+	"gemini-1.5-flash":   "gemini_1_5_flash",
+	"llama-3.2-90b":      "llama3_2_90b",
+	"llama-3.1-405b":     "llama3_1_405b",
+	"mistral-large-2":    "mistral_large_2",
+	"qwen-2.5-72b":       "qwen2p5_72b",
+	"qwen-2.5-coder-32b": "qwen2p5_coder_32b",
+	"command-r-plus":     "command_r_plus",
+}
+
+func getReverseModelMap() map[string]string {
+	reverse := make(map[string]string, len(modelMap))
+	for k, v := range modelMap {
+		reverse[v] = k
+	}
+	return reverse
+}
+
+func mapModelName(openAIModel string) string {
+	if mappedModel, exists := modelMap[openAIModel]; exists {
+		return mappedModel
+	}
+	return "deepseek_v3"
+}
+
+func reverseMapModelName(youModel string) string {
+	reverseMap := getReverseModelMap()
+	if mappedModel, exists := reverseMap[youModel]; exists {
+		return mappedModel
+	}
+	return "deepseek-chat"
+}
+
+var originalModel string
+
+func Handler(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path != "/v1/chat/completions" {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]string{
+			"status":  "You2Api Service Running...",
+			"message": "MoLoveSze...",
+		})
+		return
+	}
+
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "*")
+
+	if r.Method == "OPTIONS" {
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+
+	authHeader := r.Header.Get("Authorization")
+	if !strings.HasPrefix(authHeader, "Bearer ") {
+		http.Error(w, "Missing or invalid authorization header", http.StatusUnauthorized)
+		return
+	}
+	dsToken := strings.TrimPrefix(authHeader, "Bearer ")
+
+	var openAIReq OpenAIRequest
+	if err := json.NewDecoder(r.Body).Decode(&openAIReq); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	originalModel = openAIReq.Model
+	lastMessage := openAIReq.Messages[len(openAIReq.Messages)-1].Content
+	var chatHistory []map[string]interface{}
+	for _, msg := range openAIReq.Messages {
+		chatMsg := map[string]interface{}{
+			"question": msg.Content,
+			"answer":   "",
+		}
+		if msg.Role == "assistant" {
+			chatMsg["question"] = ""
+			chatMsg["answer"] = msg.Content
+		}
+		chatHistory = append(chatHistory, chatMsg)
+	}
+
+	chatHistoryJSON, _ := json.Marshal(chatHistory)
+
+	youReq, _ := http.NewRequest("GET", "https://you.com/api/streamingSearch", nil)
+
+	q := youReq.URL.Query()
+	q.Add("q", lastMessage)
+	q.Add("page", "1")
+	q.Add("count", "10")
+	q.Add("safeSearch", "Moderate")
+	q.Add("mkt", "zh-HK")
+	q.Add("enable_worklow_generation_ux", "true")
+	q.Add("domain", "youchat")
+	q.Add("use_personalization_extraction", "true")
+	q.Add("pastChatLength", fmt.Sprintf("%d", len(chatHistory)-1))
+	q.Add("selectedChatMode", "custom")
+	q.Add("selectedAiModel", mapModelName(openAIReq.Model))
+	q.Add("enable_agent_clarification_questions", "true")
+	q.Add("use_nested_youchat_updates", "true")
+	q.Add("chat", string(chatHistoryJSON))
+	youReq.URL.RawQuery = q.Encode()
+
+	youReq.Header = http.Header{
+		"sec-ch-ua-platform":         {"Windows"},
+		"Cache-Control":              {"no-cache"},
+		"sec-ch-ua":                  {`"Not(A:Brand";v="99", "Microsoft Edge";v="133", "Chromium";v="133"`},
+		"sec-ch-ua-bitness":          {"64"},
+		"sec-ch-ua-model":            {""},
+		"sec-ch-ua-mobile":           {"?0"},
+		"sec-ch-ua-arch":             {"x86"},
+		"sec-ch-ua-full-version":     {"133.0.3065.39"},
+		"Accept":                     {"text/event-stream"},
+		"User-Agent":                 {"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+		"sec-ch-ua-platform-version": {"19.0.0"},
+		"Sec-Fetch-Site":             {"same-origin"},
+		"Sec-Fetch-Mode":             {"cors"},
+		"Sec-Fetch-Dest":             {"empty"},
+		"Host":                       {"you.com"},
+	}
+
+	cookies := getCookies(dsToken)
+	var cookieStrings []string
+	for name, value := range cookies {
+		cookieStrings = append(cookieStrings, fmt.Sprintf("%s=%s", name, value))
+	}
+	youReq.Header.Add("Cookie", strings.Join(cookieStrings, ";"))
+
+	if !openAIReq.Stream {
+		handleNonStreamingResponse(w, youReq)
+		return
+	}
+
+	handleStreamingResponse(w, youReq)
+}
+
+func getCookies(dsToken string) map[string]string {
+	return map[string]string{
+		"guest_has_seen_legal_disclaimer": "true",
+		"youchat_personalization":         "true",
+		"DS":                              dsToken,
+		"you_subscription":                "youpro_standard_year",
+		"youpro_subscription":             "true",
+		"ai_model":                        "deepseek_r1",
+		"youchat_smart_learn":             "true",
+	}
+}
+
+func handleNonStreamingResponse(w http.ResponseWriter, youReq *http.Request) {
+	client := &http.Client{
+		Timeout: 60 * time.Second,
+	}
+	resp, err := client.Do(youReq)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	defer resp.Body.Close()
+
+	var fullResponse strings.Builder
+	scanner := bufio.NewScanner(resp.Body)
+
+	buf := make([]byte, 0, 64*1024)
+	scanner.Buffer(buf, 1024*1024)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "event: youChatToken") {
+			scanner.Scan()
+			data := scanner.Text()
+			if !strings.HasPrefix(data, "data: ") {
+				continue
+			}
+			var token YouChatResponse
+			if err := json.Unmarshal([]byte(strings.TrimPrefix(data, "data: ")), &token); err != nil {
+				continue
+			}
+			fullResponse.WriteString(token.YouChatToken)
+		}
+	}
+
+	if scanner.Err() != nil {
+		http.Error(w, "Error reading response", http.StatusInternalServerError)
+		return
+	}
+
+	openAIResp := OpenAIResponse{
+		ID:      "chatcmpl-" + fmt.Sprintf("%d", time.Now().Unix()),
+		Object:  "chat.completion",
+		Created: time.Now().Unix(),
+		Model:   reverseMapModelName(mapModelName(originalModel)),
+		Choices: []OpenAIChoice{
+			{
+				Message: Message{
+					Role:    "assistant",
+					Content: fullResponse.String(),
+				},
+				Index:        0,
+				FinishReason: "stop",
+			},
+		},
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(openAIResp); err != nil {
+		http.Error(w, "Error encoding response", http.StatusInternalServerError)
+		return
+	}
+}
+
+func handleStreamingResponse(w http.ResponseWriter, youReq *http.Request) {
+	client := &http.Client{}
+	resp, err := client.Do(youReq)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	defer resp.Body.Close()
+
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+
+	scanner := bufio.NewScanner(resp.Body)
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		if strings.HasPrefix(line, "event: youChatToken") {
+			scanner.Scan()
+			data := scanner.Text()
+
+			var token YouChatResponse
+			json.Unmarshal([]byte(strings.TrimPrefix(data, "data: ")), &token)
+
+			openAIResp := OpenAIStreamResponse{
+				ID:      "chatcmpl-" + fmt.Sprintf("%d", time.Now().Unix()),
+				Object:  "chat.completion.chunk",
+				Created: time.Now().Unix(),
+				Model:   reverseMapModelName(mapModelName(originalModel)),
+				Choices: []Choice{
+					{
+						Delta: Delta{
+							Content: token.YouChatToken,
+						},
+						Index:        0,
+						FinishReason: "",
+					},
+				},
+			}
+
+			respBytes, _ := json.Marshal(openAIResp)
+			fmt.Fprintf(w, "data: %s\n\n", string(respBytes))
+			w.(http.Flusher).Flush()
+		}
+	}
+}

config/config.go

@@ -0,0 +1,49 @@
+package config
+
+import (
+	"os"
+	"strconv"
+)
+
+type Config struct {
+    Port     int         `json:"port"`
+    LogLevel string      `json:"log_level"`
+    Proxy    ProxyConfig `json:"proxy"`
+    // 其他配置项...
+}
+
+func Load() (*Config, error) {
+    config := &Config{
+        Port:     8080,
+        LogLevel: "info",
+        Proxy: ProxyConfig{
+            EnableProxy:     getEnvBool("ENABLE_PROXY", false),
+            ProxyURL:       getEnv("PROXY_URL", ""),
+            ProxyTimeoutMS: getEnvInt("PROXY_TIMEOUT_MS", 5000),
+        },
+    }
+    return config, nil
+}
+
+func getEnv(key, defaultValue string) string {
+    if value, exists := os.LookupEnv(key); exists {
+        return value
+    }
+    return defaultValue
+}
+
+func getEnvBool(key string, defaultValue bool) bool {
+    if value, exists := os.LookupEnv(key); exists {
+        return value == "true"
+    }
+    return defaultValue
+}
+
+func getEnvInt(key string, defaultValue int) int {
+    if value, exists := os.LookupEnv(key); exists {
+        if intValue, err := strconv.Atoi(value); err == nil {
+            return intValue
+        }
+    }
+    return defaultValue
+} 

config/proxy_config.go

@@ -0,0 +1,16 @@
+package config
+
+type ProxyConfig struct {
+    EnableProxy     bool   `json:"enable_proxy"`
+    ProxyURL       string `json:"proxy_url"`
+    ProxyTimeoutMS int    `json:"proxy_timeout_ms"`
+}
+
+func (c *Config) WithProxy() *Config {
+    c.Proxy = ProxyConfig{
+        EnableProxy:     true,
+        ProxyURL:       "http://your-proxy-server:8080",
+        ProxyTimeoutMS: 5000,
+    }
+    return c
+} 

docker-compose.yml

@@ -0,0 +1,35 @@
+version: '3.8'
+
+services:
+  you2api:
+    build: .
+    container_name: you2api
+    ports:
+      - "8080:8080"
+    environment:
+      - PORT=8080
+      - ENABLE_PROXY=false
+      - PROXY_URL=
+      - PROXY_TIMEOUT_MS=5000
+      - LOG_LEVEL=info
+    restart: unless-stopped
+
+  # 如果需要添加 Prometheus 监控
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: prometheus
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./prometheus.yml:/etc/prometheus/prometheus.yml
+    depends_on:
+      - you2api
+
+  # 如果需要添加 Grafana 监控面板
+  grafana:
+    image: grafana/grafana:latest
+    container_name: grafana
+    ports:
+      - "3000:3000"
+    depends_on:
+      - prometheus 

go.mod

@@ -0,0 +1,3 @@
+module you2api
+
+go 1.22.2

logger/logger.go

@@ -0,0 +1,33 @@
+package logger
+
+import (
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+var log *zap.Logger
+
+func Init(level string) error {
+	config := zap.NewProductionConfig()
+	config.Level.SetLevel(getLogLevel(level))
+	
+	logger, err := config.Build()
+	if err != nil {
+		return err
+	}
+	
+	log = logger
+	return nil
+}
+
+func getLogLevel(level string) zapcore.Level {
+	switch level {
+	case "debug":
+		return zapcore.DebugLevel
+	case "info":
+		return zapcore.InfoLevel
+	// ... 其他级别
+	default:
+		return zapcore.InfoLevel
+	}
+} 

metrics/metrics.go

@@ -0,0 +1,19 @@
+package metrics
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+var (
+	RequestCounter = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "http_requests_total",
+			Help: "HTTP请求总数",
+		},
+		[]string{"method", "endpoint", "status"},
+	)
+)
+
+func Init() {
+	prometheus.MustRegister(RequestCounter)
+} 

prometheus.yml

@@ -0,0 +1,7 @@
+global:
+  scrape_interval: 15s
+
+scrape_configs:
+  - job_name: 'you2api'
+    static_configs:
+      - targets: ['you2api:8080'] 

proxy/proxy.go

@@ -0,0 +1,46 @@
+package proxy
+
+import (
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"time"
+)
+
+type Proxy struct {
+	target     *url.URL
+	proxy      *httputil.ReverseProxy
+	timeoutMS  int
+}
+
+func NewProxy(targetURL string, timeoutMS int) (*Proxy, error) {
+	target, err := url.Parse(targetURL)
+	if err != nil {
+		return nil, err
+	}
+
+	proxy := &Proxy{
+		target:    target,
+		timeoutMS: timeoutMS,
+	}
+
+	proxy.proxy = &httputil.ReverseProxy{
+		Director: proxy.director,
+		Transport: &http.Transport{
+			Proxy: http.ProxyURL(target),
+			ResponseHeaderTimeout: time.Duration(timeoutMS) * time.Millisecond,
+		},
+	}
+
+	return proxy, nil
+}
+
+func (p *Proxy) director(req *http.Request) {
+	req.URL.Scheme = p.target.Scheme
+	req.URL.Host = p.target.Host
+	req.Host = p.target.Host
+}
+
+func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	p.proxy.ServeHTTP(w, r)
+} 

start.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	api "you2api/api" // 请替换为您的实际项目名
+	config "you2api/config"
+	proxy "you2api/proxy"
+)
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatalf("运行错误: %v", err)
+	}
+}
+
+func run() error {
+	// 加载配置
+	config, err := config.Load()
+	if err != nil {
+		return fmt.Errorf("加载配置失败: %w", err)
+	}
+
+	// 如果启用代理
+	if config.Proxy.EnableProxy {
+		proxy, err := proxy.NewProxy(config.Proxy.ProxyURL, config.Proxy.ProxyTimeoutMS)
+		if err != nil {
+			return fmt.Errorf("初始化代理失败: %w", err)
+		}
+		
+		// 注册代理处理器
+		http.Handle("/proxy/", http.StripPrefix("/proxy", proxy))
+	}
+
+	// 注册普通API处理器
+	http.HandleFunc("/api/", api.Handler)
+
+	port := fmt.Sprintf(":%d", config.Port)
+	fmt.Printf("Server is running on http://localhost%s\n", port)
+
+	// 启动服务器
+	if err := http.ListenAndServe(port, nil); err != nil {
+		return fmt.Errorf("启动服务器失败: %w", err)
+	}
+	return nil
+}

start_test.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestRun(t *testing.T) {
+	tests := []struct {
+		name    string
+		wantErr bool
+	}{
+		{
+			name:    "正常运行",
+			wantErr: false,
+		},
+	}
+	
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := run(); (err != nil) != tt.wantErr {
+				t.Errorf("run() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}