Upload 48 files

.env.example

@@ -0,0 +1,22 @@
+# 服务器配置
+PORT=8002
+DEBUG=false
+
+# API配置
+# ⚠️ 警告：生产环境请务必修改默认 API_KEY！
+API_KEY=0000
+MODELS=claude-sonnet-4.6
+SYSTEM_PROMPT_INJECT=
+
+# 请求配置
+TIMEOUT=60  # 请求超时时间（秒）
+MAX_INPUT_LENGTH=200000  # 最大输入长度
+
+# 浏览器指纹配置
+USER_AGENT=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36
+UNMASKED_VENDOR_WEBGL=Google Inc. (Intel)
+UNMASKED_RENDERER_WEBGL=ANGLE (Intel, Intel(R) UHD Graphics 620 Direct3D11 vs_5_0 ps_5_0, D3D11)
+
+# Cursor配置
+# SCRIPT_URL 需要根据实际情况获取，可能需要定期更新
+SCRIPT_URL=https://cursor.com/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/a-4-a/c.js?i=0&v=3&h=cursor.com

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+docs/images/home.png filter=lfs diff=lfs merge=lfs -text
+docs/images/play1.png filter=lfs diff=lfs merge=lfs -text
+docs/images/play2.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,67 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Go build output
+cursor2api-go
+cursor2api-go.exe
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool
+*.out
+
+# Go workspace file
+go.work
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.temp
+
+# Build artifacts
+dist/
+build/
+
+# Python (if any remains)
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Node.js
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Docker
+.dockerignore

.goreleaser.yml

@@ -0,0 +1,58 @@
+# Build customization
+builds:
+  - main: ./main.go
+    binary: cursor2api-go
+    goos:
+      - windows
+      - darwin
+      - linux
+    goarch:
+      - amd64
+      - arm64
+    env:
+      - CGO_ENABLED=0
+    ldflags:
+      - -s -w
+      - -X main.version={{.Version}}
+      - -X main.commit={{.Commit}}
+      - -X main.date={{.Date}}
+
+# Archive customization
+archives:
+  - name_template: >-
+      {{ .ProjectName }}_
+      {{- title .Os }}_
+      {{- if eq .Arch "amd64" }}x86_64
+      {{- else if eq .Arch "386" }}i386
+      {{- else }}{{ .Arch }}{{ end }}
+      {{- if .Arm }}v{{ .Arm }}{{ end }}
+    format: tar.gz
+    format_overrides:
+      - goos: windows
+        format: zip
+
+# Checksum customization
+checksum:
+  name_template: 'checksums.txt'
+  algorithm: sha256
+
+# Changelog customization
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'
+
+# Release customization
+release:
+  name_template: "{{.ProjectName}}-v{{.Version}}"
+  github:
+    owner: "{{ .Env.GITHUB_REPOSITORY_OWNER }}"
+    name: "{{ .Env.GITHUB_REPOSITORY_NAME }}"
+
+# GitHub Actions integration
+github_urls:
+  api: https://api.github.com/
+  upload: https://uploads.github.com/
+  download: https://github.com/

Dockerfile

@@ -0,0 +1,39 @@
+# Build stage
+FROM golang:1.24-bookworm AS builder
+
+ENV GO111MODULE=on
+
+WORKDIR /app
+
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+
+# Build a static binary
+RUN CGO_ENABLED=0 GOOS=linux go build -a -o cursor2api-go .
+
+# Runtime stage
+FROM node:20-bookworm-slim
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PORT=7860
+WORKDIR /app
+
+COPY --from=builder /app/cursor2api-go /app/
+COPY --from=builder /app/static /app/static
+COPY --from=builder /app/jscode /app/jscode
+
+# Non-root user (HF Spaces friendly)
+RUN chown -R node:node /app
+USER node
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \
+    CMD node -e "const http=require('http');const port=process.env.PORT||7860;http.get('http://127.0.0.1:'+port+'/health',r=>process.exit(r.statusCode===200?0:1)).on('error',()=>process.exit(1));"
+
+CMD ["./cursor2api-go"]

LICENSE

@@ -0,0 +1,16 @@
+PolyForm Noncommercial License Notice
+
+This project is licensed under the PolyForm Noncommercial License 1.0.0.
+
+Official license text:
+https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+SPDX identifier:
+PolyForm-Noncommercial-1.0.0
+
+Required Notice: Copyright (c) 2025-2026 libaxuan
+
+Summary:
+- Noncommercial use is permitted.
+- Commercial use is not permitted under this license.
+- See the official license text at the URL above for the complete terms.

TROUBLESHOOTING.md

@@ -0,0 +1,114 @@
+# 故障排除指南
+
+## 403 Access Denied 错误
+
+### 问题描述
+在使用一段时间后,服务突然开始返回 `403 Access Denied` 错误:
+```
+ERRO[0131] Cursor API returned non-OK status             status_code=403
+ERRO[0131] Failed to create chat completion              error="{\"error\":\"Access denied\"}"
+```
+
+### 原因分析
+1. **Token 过期**: `x-is-human` token 缓存时间过长,导致 token 失效
+2. **频率限制**: 短时间内发送过多请求触发了 Cursor API 的速率限制
+3. **重复 Token**: 使用相同的 token 进行多次请求被识别为异常行为
+
+### 解决方案
+
+#### 1. 已实施的自动修复
+最新版本已经包含以下改进:
+
+- **动态浏览器指纹**: 每次请求使用真实且随机的浏览器指纹信息
+  - 根据操作系统自动选择合适的平台配置 (Windows/macOS/Linux)
+  - 随机 Chrome 版本 (120-130)
+  - 随机语言设置和 Referer
+  - 真实的 User-Agent 和 sec-ch-ua headers
+- **缩短缓存时间**: 将 `x-is-human` token 缓存时间从 30 分钟缩短到 1 分钟
+- **自动重试机制**: 遇到 403 错误时自动清除缓存并重试(最多 2 次)
+- **指纹刷新**: 403 错误时自动刷新浏览器指纹配置
+- **错误恢复**: 失败时自动清除缓存,确保下次请求使用新 token
+- **指数退避**: 重试时使用递增的等待时间
+
+#### 2. 手动解决步骤
+如果问题持续存在:
+
+1. **重启服务**:
+   ```bash
+   # 停止当前服务 (Ctrl+C)
+   # 重新启动
+   ./cursor2api-go
+   ```
+
+2. **检查日志**:
+   查看是否有以下日志:
+   - `Received 403 Access Denied, clearing token cache and retrying...` - 自动重试
+   - `Failed to fetch x-is-human token` - Token 获取失败
+   - `Fetched x-is-human token` - Token 获取成功
+
+3. **等待冷却期**:
+   如果频繁遇到 403 错误,建议等待 5-10 分钟后再使用
+
+4. **检查网络**:
+   确保能够访问 `https://cursor.com`
+
+#### 3. 预防措施
+
+1. **控制请求频率**: 避免在短时间内发送大量请求
+2. **监控日志**: 注意 `x-is-human token` 的获取频率
+3. **合理配置超时**: 在 `.env` 文件中设置合理的超时时间
+
+### 配置建议
+
+在 `.env` 文件中:
+```bash
+TIMEOUT=120  # 增加超时时间,避免频繁重试
+MAX_INPUT_LENGTH=100000  # 限制输入长度,减少请求大小
+```
+
+### 调试模式
+
+如果需要查看详细的调试信息,可以启用调试模式:
+```bash
+# 方式 1: 修改 .env 文件
+DEBUG=true
+
+# 方式 2: 使用环境变量
+DEBUG=true ./cursor2api-go
+```
+
+这将显示:
+- 每次请求的 `x-is-human` token (前 50 字符)
+- 请求的 payload 大小
+- 重试次数
+- 详细的错误信息
+
+## 其他常见问题
+
+### Cloudflare 403 错误
+如果看到 `Cloudflare 403` 错误,说明请求被 Cloudflare 防火墙拦截。这通常是因为:
+- IP 被标记为可疑
+- User-Agent 不匹配
+- 缺少必要的浏览器指纹
+
+**解决方案**: 检查 `.env` 文件中的浏览器指纹配置（`USER_AGENT`、`UNMASKED_VENDOR_WEBGL`、`UNMASKED_RENDERER_WEBGL`）是否正确。
+
+### 连接超时
+如果频繁出现连接超时:
+1. 检查网络连接
+2. 增加 `.env` 文件中的 `TIMEOUT` 配置值
+3. 检查防火墙设置
+
+### Token 获取失败
+如果无法获取 `x-is-human` token:
+1. 检查 `.env` 文件中的 `SCRIPT_URL` 配置是否正确
+2. 确保 `jscode/main.js` 和 `jscode/env.js` 文件存在
+3. 检查 Node.js 环境是否正常安装（Node.js 18+）
+
+## 联系支持
+
+如果问题仍未解决,请提供以下信息:
+1. 完整的错误日志
+2. `.env` 文件配置（隐藏敏感信息如 `API_KEY`）
+3. 使用的 Go 版本和 Node.js 版本
+4. 操作系统信息

config/config.go

@@ -0,0 +1,200 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package config
+
+import (
+	"github.com/libaxuan/cursor2api-go/models"
+	"encoding/json"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/joho/godotenv"
+	"github.com/sirupsen/logrus"
+)
+
+// Config 应用程序配置结构
+type Config struct {
+	// 服务器配置
+	Port  int  `json:"port"`
+	Debug bool `json:"debug"`
+
+	// API配置
+	APIKey             string `json:"api_key"`
+	Models             string `json:"models"`
+	SystemPromptInject string `json:"system_prompt_inject"`
+	Timeout            int    `json:"timeout"`
+	MaxInputLength     int    `json:"max_input_length"`
+
+	// 兼容性配置
+	// KILO_TOOL_STRICT=true 时：只要请求提供了 tools，就强制/强提示模型至少发起一次工具调用
+	// 以适配 Kilo Code 这类“必须用工具”的上层编排器。
+	KiloToolStrict bool `json:"kilo_tool_strict"`
+
+	// Cursor相关配置
+	ScriptURL string `json:"script_url"`
+	FP        FP     `json:"fp"`
+}
+
+// FP 指纹配置结构
+type FP struct {
+	UserAgent               string `json:"userAgent"`
+	UNMASKED_VENDOR_WEBGL   string `json:"unmaskedVendorWebgl"`
+	UNMASKED_RENDERER_WEBGL string `json:"unmaskedRendererWebgl"`
+}
+
+// LoadConfig 加载配置
+func LoadConfig() (*Config, error) {
+	// 尝试加载.env文件
+	if err := godotenv.Load(); err != nil {
+		logrus.Debug("No .env file found, using environment variables")
+	}
+
+	config := &Config{
+		// 设置默认值
+		Port:               getEnvAsInt("PORT", 8002),
+		Debug:              getEnvAsBool("DEBUG", false),
+		APIKey:             getEnv("API_KEY", "0000"),
+		Models:             getEnv("MODELS", "claude-sonnet-4.6"),
+		SystemPromptInject: getEnv("SYSTEM_PROMPT_INJECT", ""),
+		Timeout:            getEnvAsInt("TIMEOUT", 60),
+		MaxInputLength:     getEnvAsInt("MAX_INPUT_LENGTH", 200000),
+		KiloToolStrict:     getEnvAsBool("KILO_TOOL_STRICT", false),
+		ScriptURL:          getEnv("SCRIPT_URL", "https://cursor.com/_next/static/chunks/pages/_app.js"),
+		FP: FP{
+			UserAgent:               getEnv("USER_AGENT", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"),
+			UNMASKED_VENDOR_WEBGL:   getEnv("UNMASKED_VENDOR_WEBGL", "Google Inc. (Intel)"),
+			UNMASKED_RENDERER_WEBGL: getEnv("UNMASKED_RENDERER_WEBGL", "ANGLE (Intel, Intel(R) UHD Graphics 620 Direct3D11 vs_5_0 ps_5_0, D3D11)"),
+		},
+	}
+
+	// 验证必要的配置
+	if err := config.validate(); err != nil {
+		return nil, fmt.Errorf("config validation failed: %w", err)
+	}
+
+	return config, nil
+}
+
+// validate 验证配置
+func (c *Config) validate() error {
+	if c.Port <= 0 || c.Port > 65535 {
+		return fmt.Errorf("invalid port: %d", c.Port)
+	}
+
+	if c.APIKey == "" {
+		return fmt.Errorf("API_KEY is required")
+	}
+
+	if c.Timeout <= 0 {
+		return fmt.Errorf("timeout must be positive")
+	}
+
+	if c.MaxInputLength <= 0 {
+		return fmt.Errorf("max input length must be positive")
+	}
+
+	return nil
+}
+
+// GetBaseModels 获取基础模型列表
+func (c *Config) GetBaseModels() []string {
+	modelsList := strings.Split(c.Models, ",")
+	result := make([]string, 0, len(modelsList))
+	for _, model := range modelsList {
+		if trimmed := strings.TrimSpace(model); trimmed != "" {
+			result = append(result, trimmed)
+		}
+	}
+	return result
+}
+
+// GetModels 获取模型列表
+func (c *Config) GetModels() []string {
+	return models.ExpandModelList(c.GetBaseModels())
+}
+
+// IsValidModel 检查模型是否有效
+func (c *Config) IsValidModel(model string) bool {
+	validModels := c.GetModels()
+	for _, validModel := range validModels {
+		if validModel == model {
+			return true
+		}
+	}
+	return false
+}
+
+// ToJSON 将配置序列化为JSON（用于调试）
+func (c *Config) ToJSON() string {
+	// 创建一个副本，隐藏敏感信息
+	safeCfg := *c
+	safeCfg.APIKey = "***"
+
+	data, err := json.MarshalIndent(safeCfg, "", "  ")
+	if err != nil {
+		return fmt.Sprintf("Error marshaling config: %v", err)
+	}
+	return string(data)
+}
+
+// 辅助函数
+
+// getEnv 获取环境变量，如果不存在则返回默认值
+func getEnv(key, defaultValue string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return defaultValue
+}
+
+// getEnvAsInt 获取环境变量并转换为int
+func getEnvAsInt(key string, defaultValue int) int {
+	valueStr := os.Getenv(key)
+	if valueStr == "" {
+		return defaultValue
+	}
+
+	value, err := strconv.Atoi(valueStr)
+	if err != nil {
+		logrus.Warnf("Invalid integer value for %s: %s, using default: %d", key, valueStr, defaultValue)
+		return defaultValue
+	}
+
+	return value
+}
+
+// getEnvAsBool 获取环境变量并转换为bool
+func getEnvAsBool(key string, defaultValue bool) bool {
+	valueStr := os.Getenv(key)
+	if valueStr == "" {
+		return defaultValue
+	}
+
+	value, err := strconv.ParseBool(valueStr)
+	if err != nil {
+		logrus.Warnf("Invalid boolean value for %s: %s, using default: %t", key, valueStr, defaultValue)
+		return defaultValue
+	}
+
+	return value
+}

config/config_test.go

@@ -0,0 +1,203 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package config
+
+import (
+	"os"
+	"testing"
+)
+
+func TestLoadConfig(t *testing.T) {
+	// Create a temporary .env file for testing
+	envContent := `PORT=9000
+DEBUG=true
+API_KEY=test-key
+MODELS=claude-sonnet-4.6
+SYSTEM_PROMPT_INJECT=Test prompt
+TIMEOUT=60
+MAX_INPUT_LENGTH=10000
+USER_AGENT=Test Agent
+SCRIPT_URL=https://test.com/script.js`
+
+	// Write to temporary .env file
+	err := os.WriteFile(".env", []byte(envContent), 0644)
+	if err != nil {
+		t.Fatalf("Failed to create test .env file: %v", err)
+	}
+	defer os.Remove(".env") // Clean up
+
+	config, err := LoadConfig()
+	if err != nil {
+		t.Fatalf("LoadConfig() error = %v", err)
+	}
+
+	// Test loaded values
+	if config.Port != 9000 {
+		t.Errorf("Port = %v, want 9000", config.Port)
+	}
+	if !config.Debug {
+		t.Errorf("Debug = %v, want true", config.Debug)
+	}
+	if config.APIKey != "test-key" {
+		t.Errorf("APIKey = %v, want test-key", config.APIKey)
+	}
+	if config.SystemPromptInject != "Test prompt" {
+		t.Errorf("SystemPromptInject = %v, want Test prompt", config.SystemPromptInject)
+	}
+	if config.Timeout != 60 {
+		t.Errorf("Timeout = %v, want 60", config.Timeout)
+	}
+	if config.MaxInputLength != 10000 {
+		t.Errorf("MaxInputLength = %v, want 10000", config.MaxInputLength)
+	}
+	if config.FP.UserAgent != "Test Agent" {
+		t.Errorf("UserAgent = %v, want Test Agent", config.FP.UserAgent)
+	}
+	if config.ScriptURL != "https://test.com/script.js" {
+		t.Errorf("ScriptURL = %v, want https://test.com/script.js", config.ScriptURL)
+	}
+}
+
+func TestGetModels(t *testing.T) {
+	config := &Config{
+		Models: "claude-sonnet-4.6",
+	}
+
+	models := config.GetModels()
+	expected := []string{
+		"claude-sonnet-4.6",
+		"claude-sonnet-4.6-thinking",
+	}
+
+	if len(models) != len(expected) {
+		t.Errorf("GetModels() length = %v, want %v", len(models), len(expected))
+	}
+
+	for i, model := range models {
+		if model != expected[i] {
+			t.Errorf("GetModels()[%d] = %v, want %v", i, model, expected[i])
+		}
+	}
+}
+
+func TestIsValidModel(t *testing.T) {
+	config := &Config{
+		Models: "claude-sonnet-4.6",
+	}
+
+	tests := []struct {
+		name     string
+		model    string
+		expected bool
+	}{
+		{"valid base model", "claude-sonnet-4.6", true},
+		{"valid thinking model", "claude-sonnet-4.6-thinking", true},
+		{"invalid model", "unknown-model", false},
+		{"empty model", "", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := config.IsValidModel(tt.model)
+			if result != tt.expected {
+				t.Errorf("IsValidModel(%q) = %v, want %v", tt.model, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestValidate(t *testing.T) {
+	tests := []struct {
+		name    string
+		config  *Config
+		wantErr bool
+	}{
+		{
+			name: "valid config",
+			config: &Config{
+				Port:           8000,
+				APIKey:         "test-key",
+				Timeout:        30,
+				MaxInputLength: 1000,
+			},
+			wantErr: false,
+		},
+		{
+			name: "invalid port - too low",
+			config: &Config{
+				Port:           0,
+				APIKey:         "test-key",
+				Timeout:        30,
+				MaxInputLength: 1000,
+			},
+			wantErr: true,
+		},
+		{
+			name: "invalid port - too high",
+			config: &Config{
+				Port:           70000,
+				APIKey:         "test-key",
+				Timeout:        30,
+				MaxInputLength: 1000,
+			},
+			wantErr: true,
+		},
+		{
+			name: "missing API key",
+			config: &Config{
+				Port:           8000,
+				APIKey:         "",
+				Timeout:        30,
+				MaxInputLength: 1000,
+			},
+			wantErr: true,
+		},
+		{
+			name: "invalid timeout",
+			config: &Config{
+				Port:           8000,
+				APIKey:         "test-key",
+				Timeout:        0,
+				MaxInputLength: 1000,
+			},
+			wantErr: true,
+		},
+		{
+			name: "invalid max input length",
+			config: &Config{
+				Port:           8000,
+				APIKey:         "test-key",
+				Timeout:        30,
+				MaxInputLength: 0,
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.config.validate()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

docker-compose.yml

@@ -0,0 +1,42 @@
+version: '3.8'
+
+services:
+  cursor2api:
+    build: .
+    container_name: cursor2api-go
+    restart: unless-stopped
+    ports:
+      - "8002:8002"
+    environment:
+      # 服务器配置
+      - PORT=8002
+      - DEBUG=false
+
+      # API 配置（⚠️ 生产环境请修改默认密钥）
+      - API_KEY=0000
+      - MODELS=claude-sonnet-4.6
+      - SYSTEM_PROMPT_INJECT=
+
+      # 请求配置
+      - TIMEOUT=60
+      - MAX_INPUT_LENGTH=200000
+
+      # 浏览器指纹配置
+      - USER_AGENT=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36
+      - UNMASKED_VENDOR_WEBGL=Google Inc. (Intel)
+      - UNMASKED_RENDERER_WEBGL=ANGLE (Intel, Intel(R) UHD Graphics 620 Direct3D11 vs_5_0 ps_5_0, D3D11)
+
+      # Cursor 配置
+      - SCRIPT_URL=https://cursor.com/_next/static/chunks/pages/_app.js
+    healthcheck:
+      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8002/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
+    networks:
+      - cursor2api-network
+
+networks:
+  cursor2api-network:
+    driver: bridge

docs/API_CAPABILITIES.md

@@ -0,0 +1,107 @@
+# API Capabilities
+
+## Supported
+
+- OpenAI-compatible `POST /v1/chat/completions`
+- OpenAI-compatible `POST /v1/responses`
+- OpenAI-compatible `GET /v1/models`
+- Non-stream responses with:
+  - plain assistant text
+  - assistant `tool_calls`
+- Responses API outputs with:
+  - `output_text`
+  - `function_call`, `apply_patch_call`, `shell_call`, `local_shell_call`
+- Stream responses with:
+  - `delta.content`
+  - `delta.tool_calls`
+- Responses API stream events:
+  - `response.output_text.delta`
+  - `response.function_call_arguments.delta`
+- Multi-turn context via the `messages` array
+- Tool request fields:
+  - `tools`
+  - `tool_choice`
+  - assistant history `tool_calls`
+  - tool role history `tool_call_id`
+- Automatically derived `*-thinking` public models, for example:
+  - `claude-sonnet-4.6`
+  - `claude-sonnet-4.6-thinking`
+- Bearer token auth via `Authorization: Bearer <API_KEY>`
+
+## Behavior Notes
+
+- Tool support is implemented through an internal prompt-and-parser bridge, not Cursor-native tool calling.
+- Base models keep the current model name and enable tool use.
+- `*-thinking` models map back to the same upstream base model, but also enable the internal thinking protocol.
+- Thinking is an internal bridge capability only. The public OpenAI response does not expose a separate reasoning field.
+- `previous_response_id` is supported with in-memory state only; restart clears history. For stateless use, include prior output items in `input`.
+
+## Not Supported
+
+- Anthropic `/v1/messages`
+- MCP orchestration
+- Native upstream OpenAI tool execution
+- Exposed reasoning/thinking response fields
+- Local filesystem or OS command execution through the API
+- Persisted Responses API storage or server-side conversations across restarts
+
+## Example: Non-Stream Tool Call
+
+```bash
+curl -X POST http://127.0.0.1:8002/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer 0000" \
+  -d '{
+    "model": "claude-sonnet-4.6",
+    "stream": false,
+    "messages": [
+      {"role": "user", "content": "帮我查询北京天气"}
+    ],
+    "tools": [
+      {
+        "type": "function",
+        "function": {
+          "name": "get_weather",
+          "description": "Get current weather",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "city": {"type": "string"}
+            },
+            "required": ["city"]
+          }
+        }
+      }
+    ]
+  }'
+```
+
+## Example: Thinking Model
+
+```bash
+curl -X POST http://127.0.0.1:8002/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer 0000" \
+  -d '{
+    "model": "claude-sonnet-4.6-thinking",
+    "stream": true,
+    "messages": [
+      {"role": "user", "content": "先思考，再决定是否需要工具"}
+    ],
+    "tools": [
+      {
+        "type": "function",
+        "function": {
+          "name": "lookup",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "q": {"type": "string"}
+            },
+            "required": ["q"]
+          }
+        }
+      }
+    ]
+  }'
+```

docs/DYNAMIC_HEADERS.md

@@ -0,0 +1,180 @@
+# 动态 Header 改进说明
+
+## 问题背景
+
+之前的实现中，HTTP headers 是硬编码的：
+- `sec-ch-ua-platform` 固定为 `"macOS"` 或 `"Windows"`
+- `sec-ch-ua` 固定为特定的 Chrome 版本
+- `Referer` 和 `accept-language` 固定不变
+
+这种硬编码的方式容易被 Cursor API 识别为异常请求，导致 403 错误。
+
+## 改进方案
+
+### 1. 动态浏览器指纹生成器 (`utils/headers.go`)
+
+创建了 `HeaderGenerator` 类，实现以下功能：
+
+#### 智能平台选择
+- 根据当前操作系统自动选择合适的浏览器配置
+- macOS: 支持 Intel (x86) 和 Apple Silicon (arm) 架构
+- Windows: 支持多个版本 (10.0, 11.0, 15.0)
+- Linux: 标准 x86_64 配置
+
+#### 随机化配置
+- **Chrome 版本**: 从 120-130 随机选择
+- **语言设置**: 支持 en-US, zh-CN, en-GB, ja-JP
+- **Referer**: 随机选择不同的 Cursor 页面
+- **User-Agent**: 根据平台和版本动态生成
+
+#### 真实的浏览器指纹
+生成的 headers 包含完整的浏览器指纹信息：
+```json
+{
+  "sec-ch-ua-platform": "macOS",
+  "sec-ch-ua-platform-version": "14.0.0",
+  "sec-ch-ua-arch": "arm",
+  "sec-ch-ua-bitness": "64",
+  "sec-ch-ua": "\"Google Chrome\";v=\"126\", \"Chromium\";v=\"126\", \"Not(A:Brand\";v=\"24\"",
+  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36..."
+}
+```
+
+### 2. 自动刷新机制
+
+当遇到 403 错误时：
+1. 自动刷新浏览器指纹配置
+2. 清除 x-is-human token 缓存
+3. 使用新的配置重试请求
+
+### 3. 代码改进
+
+#### 服务初始化
+```go
+type CursorService struct {
+    // ... 其他字段
+    headerGenerator *utils.HeaderGenerator
+}
+
+func NewCursorService(cfg *config.Config) *CursorService {
+    return &CursorService{
+        // ... 其他初始化
+        headerGenerator: utils.NewHeaderGenerator(),
+    }
+}
+```
+
+#### Headers 生成
+```go
+// 之前：硬编码
+func (s *CursorService) chatHeaders(xIsHuman string) map[string]string {
+    return map[string]string{
+        "sec-ch-ua-platform": `"macOS"`,  // 固定值
+        "sec-ch-ua": `"Google Chrome";v="143"...`,  // 固定版本
+        // ...
+    }
+}
+
+// 现在：动态生成
+func (s *CursorService) chatHeaders(xIsHuman string) map[string]string {
+    return s.headerGenerator.GetChatHeaders(xIsHuman)
+}
+```
+
+#### 403 错误处理
+```go
+if resp.StatusCode == http.StatusForbidden && attempt < maxRetries {
+    logrus.Warn("Received 403, refreshing browser fingerprint...")
+    
+    // 刷新浏览器指纹
+    s.headerGenerator.Refresh()
+    
+    // 清除 token 缓存
+    s.scriptMutex.Lock()
+    s.scriptCache = ""
+    s.scriptCacheTime = time.Time{}
+    s.scriptMutex.Unlock()
+    
+    // 重试
+    continue
+}
+```
+
+## 优势
+
+### 1. 更难被检测
+- 每次请求的指纹信息都可能不同
+- 模拟真实用户的多样性
+- 避免固定模式被识别
+
+### 2. 自动适应
+- 根据运行环境自动选择合适的配置
+- macOS 上运行自动使用 macOS 配置
+- Windows 上运行自动使用 Windows 配置
+
+### 3. 更好的容错性
+- 遇到 403 错误自动切换配置
+- 增加请求成功率
+- 减少人工干预
+
+### 4. 易于维护
+- 集中管理浏览器配置
+- 易于添加新的平台或版本
+- 代码更简洁清晰
+
+## 测试结果
+
+运行测试程序可以看到：
+```
+浏览器配置:
+  平台: macOS
+  平台版本: 14.0.0
+  架构: arm
+  位数: 64
+  Chrome 版本: 126
+  User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)...
+
+生成 5 个随机配置:
+1. macOS | Chrome 130 | arm
+2. macOS | Chrome 125 | arm
+3. macOS | Chrome 130 | x86
+4. macOS | Chrome 128 | arm
+5. macOS | Chrome 122 | arm
+```
+
+每次生成的配置都不同，增加了多样性。
+
+## 使用方法
+
+无需任何配置，直接使用即可：
+
+```bash
+# 重新编译
+go build -o cursor2api-go
+
+# 运行服务
+./cursor2api-go
+```
+
+服务会自动：
+- 根据操作系统选择合适的浏览器配置
+- 为每个请求生成动态 headers
+- 遇到 403 错误时自动刷新配置并重试
+
+## 日志示例
+
+启用调试模式后可以看到：
+```
+DEBU Sending request to Cursor API attempt=1 model=claude-sonnet-4.6
+WARN Received 403 Access Denied, refreshing browser fingerprint...
+DEBU Refreshed browser fingerprint platform=macOS chrome_version=124
+DEBU Sending request to Cursor API attempt=2 model=claude-sonnet-4.6
+```
+
+## 未来改进
+
+可以考虑的进一步优化：
+1. 添加更多浏览器类型 (Firefox, Safari)
+2. 支持移动设备指纹
+3. 根据成功率动态调整配置策略
+4. 添加指纹轮换策略 (定期刷新)

docs/STARTUP_OPTIMIZATION.md

@@ -0,0 +1,168 @@
+# 启动日志优化说明
+
+## 优化前 vs 优化后
+
+### 优化前（调试模式）
+启动时会显示大量 GIN 框架的调试信息：
+```
+[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
+ - using env:	export GIN_MODE=release
+ - using code:	gin.SetMode(gin.ReleaseMode)
+
+[GIN-debug] GET    /health                   --> main.setupRoutes.func1 (5 handlers)
+[GIN-debug] GET    /                         --> cursor2api-go/handlers.(*Handler).ServeDocs-fm (5 handlers)
+[GIN-debug] GET    /v1/models                --> cursor2api-go/handlers.(*Handler).ListModels-fm (6 handlers)
+[GIN-debug] POST   /v1/chat/completions      --> cursor2api-go/handlers.(*Handler).ChatCompletions-fm (6 handlers)
+[GIN-debug] GET    /static/*filepath         --> github.com/gin-gonic/gin.(*RouterGroup).createStaticHandler.func1 (5 handlers)
+[GIN-debug] HEAD   /static/*filepath         --> github.com/gin-gonic/gin.(*RouterGroup).createStaticHandler.func1 (5 handlers)
+INFO[0000] Starting Cursor2API server on port 8002
+```
+
+### 优化后（简洁模式，默认）
+启动时只显示必要的服务信息：
+```
+╔══════════════════════════════════════════════════════════════╗
+║                      Cursor2API Server                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+🚀 服务地址:  http://localhost:8002
+📚 API 文档:  http://localhost:8002/
+💊 健康检查:  http://localhost:8002/health
+🔑 API 密钥:  0000
+🤖 支持模型:  仅 `claude-sonnet-4.6` 与 `claude-sonnet-4.6-thinking`（thinking 为派生公开模型）
+
+✨ 服务已启动，按 Ctrl+C 停止
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## 主要改进
+
+### 1. 默认使用简洁模式
+- 修改 `.env.example` 中 `DEBUG=false`
+- 生产环境默认不显示调试信息
+- 启动输出更清爽、专业
+
+### 2. 美观的启动横幅
+- 使用 Unicode 框线字符绘制横幅
+- 使用 Emoji 图标增强可读性
+- 清晰展示关键信息：
+  - 🚀 服务地址
+  - 📚 API 文档
+  - 💊 健康检查
+  - 🔑 API 密钥
+  - 🤖 支持的模型
+
+### 3. 条件性日志输出
+- 只在 `DEBUG=true` 时显示详细日志
+- GIN 的 Logger 中间件仅在调试模式启用
+- 减少生产环境的日志噪音
+
+### 4. 智能模型显示
+- 模型数量 > 3 时，只显示第一个和总数
+- 避免启动信息过长
+- 保持输出简洁
+
+## 代码改进
+
+### main.go
+```go
+// 设置日志级别和 GIN 模式
+if cfg.Debug {
+    logrus.SetLevel(logrus.DebugLevel)
+    gin.SetMode(gin.DebugMode)
+} else {
+    logrus.SetLevel(logrus.InfoLevel)
+    gin.SetMode(gin.ReleaseMode)
+}
+
+// 只在 Debug 模式下启用 GIN 的日志
+if cfg.Debug {
+    router.Use(gin.Logger())
+}
+
+// 打印启动信息
+printStartupBanner(cfg)
+```
+
+### printStartupBanner 函数
+```go
+func printStartupBanner(cfg *config.Config) {
+    banner := `
+╔══════════════════════════════════════════════════════════════╗
+║                      Cursor2API Server                       ║
+╚══════════════════════════════════════════════════════════════╝
+`
+    fmt.Println(banner)
+    
+    fmt.Printf("🚀 服务地址:  http://localhost:%d\n", cfg.Port)
+    fmt.Printf("📚 API 文档:  http://localhost:%d/\n", cfg.Port)
+    fmt.Printf("💊 健康检查:  http://localhost:%d/health\n", cfg.Port)
+    fmt.Printf("🔑 API 密钥:  %s\n", cfg.APIKey)
+    
+    models := cfg.GetModels()
+    if len(models) > 3 {
+        fmt.Printf("🤖 支持模型:  %s 等 %d 个模型\n", models[0], len(models))
+    } else {
+        fmt.Printf("🤖 支持模型:  %v\n", models)
+    }
+    
+    if cfg.Debug {
+        fmt.Println("🐛 调试模式:  已启用")
+    }
+    
+    fmt.Println("\n✨ 服务已启动，按 Ctrl+C 停止")
+    fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+}
+```
+
+## 使用方法
+
+### 简洁模式（默认）
+```bash
+./cursor2api-go
+```
+
+或者使用启动脚本：
+```bash
+./start.sh
+```
+
+### 调试模式
+
+**方式 1**: 修改 `.env` 文件
+```bash
+DEBUG=true
+```
+
+**方式 2**: 临时启用
+```bash
+DEBUG=true ./cursor2api-go
+```
+
+### 调试模式会显示
+- ✅ 详细的 GIN 路由信息
+- ✅ 每个请求的详���日志
+- ✅ x-is-human token 信息
+- ✅ 浏览器指纹配置
+- ✅ 重试和错误处理详情
+
+## 优势
+
+1. **更专业** - 简洁的输出适合生产环境
+2. **更清晰** - 关键信息一目了然
+3. **更美观** - 使用 Unicode 和 Emoji 增强视觉效果
+4. **更灵活** - 可以随时切换调试模式
+5. **更友好** - 新用户更容易理解服务状态
+
+## 兼容性
+
+- ✅ 完全向后兼容
+- ✅ 不影响现有功能
+- ✅ 可以随时切换模式
+- ✅ 支持所有平台（Windows/macOS/Linux）
+
+## 注意事项
+
+1. **首次使用**: 需要更新 `.env` 文件（或删除后重新生成）
+2. **调试问题**: 遇到问题时，建议启用 `DEBUG=true` 查看详细日志
+3. **生产部署**: 建议使用 `DEBUG=false` 以获得最佳性能和简洁输出

docs/images/.gitkeep

@@ -0,0 +1 @@
+This directory holds README screenshots (e.g. home.png, tool-calls.png).

go.md

@@ -0,0 +1,216 @@
+# Cursor2API Go 实现说明：OpenAI `chat/completions` 下的 thinking + tools
+
+本文档只描述当前 Go 仓库已经实现或明确约束的行为，不再沿用旧的 Deno `/v1/messages` 迁移口径。
+
+## 1. 当前范围
+
+当前仓库只支持两个公开接口：
+
+- `GET /v1/models`
+- `POST /v1/chat/completions`
+
+不实现 `/v1/messages`，也不承诺 Anthropic 原生 block/SSE 兼容。
+
+## 2. 真实能力边界
+
+### 2.1 公开模型目录
+
+配置项 `MODELS` 只填写基础模型，例如：
+
+```env
+MODELS=claude-sonnet-4.6
+```
+
+服务会自动向外暴露两类模型：
+
+- 基础模型：`claude-sonnet-4.6`
+- thinking 派生模型：`claude-sonnet-4.6-thinking`
+
+约定如下：
+
+- 基础模型：保留现有模型名，启用 tool 能力。
+- `-thinking` 模型：自动映射回基础模型出站，同时启用 thinking 和 tool 能力。
+- 不允许继续派生 `-thinking-thinking`。
+
+### 2.2 外部接口契约
+
+当前实现的是 OpenAI `chat/completions` 兼容面：
+
+- 请求支持 `messages`
+- 请求支持 `tools`
+- 请求支持 `tool_choice`
+- assistant 历史消息支持 `tool_calls`
+- tool 历史消息支持 `tool_call_id`
+- 响应支持非流式 `message.tool_calls`
+- 响应支持流式 `delta.tool_calls`
+
+thinking 不作为 OpenAI 独立字段对外暴露。它只作为内部 prompt 协议与解析协议使用。
+
+## 3. 请求侧链路
+
+### 3.1 入口文件
+
+- `handlers/handler.go`
+- `services/cursor.go`
+- `services/cursor_protocol.go`
+
+### 3.2 处理步骤
+
+1. `handlers.ChatCompletions` 绑定并校验 OpenAI 请求。
+2. `CursorService.buildCursorRequest(...)` 解析模型能力：
+   - `claude-sonnet-4.6` -> 基础模型
+   - `claude-sonnet-4.6-thinking` -> 基础模型 + thinking 开启
+3. `tool_choice` 被解析为三类模式：
+   - `auto`
+   - `none`
+   - `required`
+   - 或 `{"type":"function","function":{"name":"..."}}`
+4. 工具定义被统一校验：
+   - 仅支持 `type=function`
+   - `function.name` 必填
+   - 不允许重名
+5. 构造单次请求专用 `TriggerSignal`，格式：
+
+```text
+<<CALL_xxxxxxxx>>
+```
+
+6. 构造发往 Cursor 的纯文本消息。
+
+## 4. 内部 prompt 协议
+
+上游 Cursor 仍然只收到文本消息，不使用原生 OpenAI tool calling。
+
+### 4.1 tool 协议
+
+当请求含有 `tools` 且 `tool_choice != "none"` 时，system message 会注入：
+
+- 工具桥接说明
+- tool 调用格式约束
+- `<function_list>` 工具清单
+- `required` / 指定 function 的额外约束
+
+模型被要求按如下格式输出工具调用：
+
+```text
+<<CALL_xxxxxxxx>>
+<invoke name="tool_name">{"arg":"value"}</invoke>
+```
+
+### 4.2 thinking 协议
+
+当请求命中 `*-thinking` 模型时：
+
+- system prompt 注入 thinking 规则
+- 每条 user message 追加固定 thinking hint
+
+hint 为：
+
+```text
+Use <thinking>...</thinking> for hidden reasoning when it helps. Keep your final visible answer outside the thinking tags.
+```
+
+### 4.3 历史消息回放
+
+为了让多轮 tool loop 继续工作，OpenAI 历史消息会被回放成内部文本协议：
+
+- assistant `tool_calls` -> `TriggerSignal + <invoke ...>`
+- tool message -> `<tool_result id="...">...</tool_result>`
+
+普通 `system/user/assistant` 文本则继续按 Cursor `parts[].text` 发送。
+
+## 5. 响应解析链路
+
+### 5.1 入口文件
+
+- `services/cursor.go`
+- `utils/cursor_protocol.go`
+- `utils/utils.go`
+
+### 5.2 解析步骤
+
+1. `consumeSSE(...)` 读取 Cursor SSE。
+2. 每个 `delta` 文本片段进入 `CursorProtocolParser`。
+3. 解析器增量产出三类内部事件：
+   - `text`
+   - `thinking`
+   - `tool_call`
+4. `thinking` 只保留在内部事件层，不直接回写给客户端。
+
+### 5.3 解析规则
+
+- `<thinking>...</thinking>` 在 thinking 模型下会被消费为内部 thinking 事件。
+- `TriggerSignal + <invoke ...>` 会被消费为工具调用事件。
+- 不完整标签会在流结束时降级为普通文本，避免丢内容。
+- 多个连续 `<invoke>` 会逐个产出，不再只保留第一个。
+
+## 6. OpenAI 响应写回
+
+### 6.1 非流式
+
+非流式响应会在 `services.CursorService.ChatCompletionNonStream(...)` 中聚合内部事件：
+
+- 只有文本时，返回普通 `message.content`
+- 有工具调用时，返回 assistant `tool_calls`
+- 若本轮出现工具调用，`finish_reason = "tool_calls"`
+- 否则 `finish_reason = "stop"`
+
+为提升与部分编排器（例如 Kilo Code）在“必须用工具”场景下的兼容性：
+
+- 当请求含 `tools` 且被判定为“必须至少调用一次工具”（`tool_choice=required/指定函数`，或启用 `KILO_TOOL_STRICT`）时，
+  如果第一轮没有产出任何 `tool_calls`，服务会自动重试 1 次（仅非流式）。
+
+### 6.2 流式
+
+`utils.StreamChatCompletion(...)` 会输出：
+
+- 首个 role chunk：`assistant`
+- 文本 chunk：`delta.content`
+- 工具调用 chunk：`delta.tool_calls`
+- 收尾 chunk：
+  - 有工具调用 -> `finish_reason = "tool_calls"`
+  - 无工具调用 -> `finish_reason = "stop"`
+
+thinking 内容不会作为独立 OpenAI 字段透出。
+
+## 7. 代码落点
+
+本次能力集中在以下模块：
+
+- `models/`
+  - OpenAI request/response/tool 类型
+  - thinking 模型派生规则
+  - 基础模型到 Cursor 模型的映射
+- `config/`
+  - `MODELS` 基础模型配置
+  - 自动扩展 `*-thinking` 公开模型目录
+- `services/cursor_protocol.go`
+  - `tool_choice` 解析
+  - 工具定义校验
+  - OpenAI 历史消息到 Cursor 文本协议的转换
+- `utils/cursor_protocol.go`
+  - Cursor 文本增量到 `text/thinking/tool_call` 事件的解析
+- `utils/utils.go`
+  - OpenAI 流式/非流式响应写回
+
+## 8. 测试基线
+
+当前测试覆盖以下关键路径：
+
+- `MODELS` 自动扩展基础模型和 `-thinking` 模型
+- thinking 模型回落到基础出站模型
+- tool prompt 注入与 tool history 回放
+- `<thinking>` / `<invoke>` 的增量解析
+- 流式 `delta.tool_calls`
+- 非流式 `message.tool_calls`
+- 纯文本聊天回归不破坏
+
+## 9. 非目标
+
+当前不做以下内容：
+
+- Anthropic `/v1/messages`
+- MCP
+- 原生 OpenAI tool execution
+- 可见的 reasoning/thinking 对外字段
+- 图像、文档、文件等多模态 block 协议

go.mod

@@ -0,0 +1,51 @@
+module github.com/libaxuan/cursor2api-go
+
+go 1.24
+
+require (
+	github.com/gin-gonic/gin v1.10.0
+	github.com/imroc/req/v3 v3.55.0
+	github.com/joho/godotenv v1.5.1
+	github.com/sirupsen/logrus v1.9.3
+)
+
+require (
+	github.com/andybalholm/brotli v1.2.0 // indirect
+	github.com/bytedance/sonic v1.11.6 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/cloudflare/circl v1.6.1 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.20.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
+	github.com/icholy/digest v1.1.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/quic-go/qpack v0.5.1 // indirect
+	github.com/quic-go/quic-go v0.53.0 // indirect
+	github.com/refraction-networking/utls v1.7.3 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.12 // indirect
+	go.uber.org/mock v0.5.2 // indirect
+	golang.org/x/arch v0.8.0 // indirect
+	golang.org/x/crypto v0.39.0 // indirect
+	golang.org/x/mod v0.25.0 // indirect
+	golang.org/x/net v0.41.0 // indirect
+	golang.org/x/sync v0.15.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/text v0.26.0 // indirect
+	golang.org/x/tools v0.34.0 // indirect
+	google.golang.org/protobuf v1.34.1 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,124 @@
+github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ=
+github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
+github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
+github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
+github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0=
+github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
+github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
+github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBExVwjEviJTixqxL8=
+github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
+github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/icholy/digest v1.1.0 h1:HfGg9Irj7i+IX1o1QAmPfIBNu/Q5A5Tu3n/MED9k9H4=
+github.com/icholy/digest v1.1.0/go.mod h1:QNrsSGQ5v7v9cReDI0+eyjsXGUoRSUZQHeQ5C4XLa0Y=
+github.com/imroc/req/v3 v3.55.0 h1:vg2Q33TGU12wZWZyPkiPbCGGTeiOmlEOdOwHLH03//I=
+github.com/imroc/req/v3 v3.55.0/go.mod h1:MOn++r2lE4+du3nuefTaPGQ6pY3/yRP2r1pFK1BUqq0=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
+github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
+github.com/quic-go/quic-go v0.53.0 h1:QHX46sISpG2S03dPeZBgVIZp8dGagIaiu2FiVYvpCZI=
+github.com/quic-go/quic-go v0.53.0/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY=
+github.com/refraction-networking/utls v1.7.3 h1:L0WRhHY7Oq1T0zkdzVZMR6zWZv+sXbHB9zcuvsAEqCo=
+github.com/refraction-networking/utls v1.7.3/go.mod h1:TUhh27RHMGtQvjQq+RyO11P6ZNQNBb3N0v7wsEjKAIQ=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
+github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
+go.uber.org/mock v0.5.2 h1:LbtPTcP8A5k9WPXj54PPPbjcI4Y6lhyOZXn+VS7wNko=
+go.uber.org/mock v0.5.2/go.mod h1:wLlUxC2vVTPTaE3UD51E0BGOAElKrILxhVSDYQLld5o=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
+golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
+golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
+golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
+golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
+golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
+golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
+golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
+golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo=
+golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
+google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU=
+gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

handlers/handler.go

@@ -0,0 +1,384 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package handlers
+
+import (
+	"github.com/libaxuan/cursor2api-go/config"
+	"github.com/libaxuan/cursor2api-go/middleware"
+	"github.com/libaxuan/cursor2api-go/models"
+	"github.com/libaxuan/cursor2api-go/services"
+	"github.com/libaxuan/cursor2api-go/utils"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+// Handler 处理器结构
+type Handler struct {
+	config        *config.Config
+	cursorService *services.CursorService
+	docsContent   []byte
+	responseStore *services.ResponseStore
+}
+
+// NewHandler 创建新的处理器
+func NewHandler(cfg *config.Config) *Handler {
+	cursorService := services.NewCursorService(cfg)
+
+	// 预加载文档内容
+	docsPath := "static/docs.html"
+	var docsContent []byte
+
+	if data, err := os.ReadFile(docsPath); err == nil {
+		docsContent = data
+	} else {
+		// 如果文件不存在，使用默认的简单HTML页面
+		simpleHTML := `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cursor2API - Go Version</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            max-width: 800px;
+            margin: 50px auto;
+            padding: 20px;
+            background-color: #f5f5f5;
+        }
+        .container {
+            background: white;
+            padding: 30px;
+            border-radius: 10px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+        }
+        h1 {
+            color: #333;
+            border-bottom: 2px solid #007bff;
+            padding-bottom: 10px;
+        }
+        .info {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 8px;
+            margin: 20px 0;
+            border-left: 4px solid #007bff;
+        }
+        code {
+            background: #e9ecef;
+            padding: 2px 6px;
+            border-radius: 4px;
+            font-family: 'Courier New', monospace;
+        }
+        .endpoint {
+            background: #e3f2fd;
+            padding: 10px;
+            margin: 10px 0;
+            border-radius: 5px;
+            border-left: 3px solid #2196f3;
+        }
+        .status-ok {
+            color: #28a745;
+            font-weight: bold;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🚀 Cursor2API - Go Version</h1>
+        
+        <div class="info">
+            <p><strong>Status:</strong> <span class="status-ok">✅ Running</span></p>
+            <p><strong>Version:</strong> Go Implementation</p>
+            <p><strong>Description:</strong> OpenAI-compatible chat completions proxy for Cursor AI</p>
+        </div>
+        
+        <div class="info">
+            <h3>📡 Available Endpoints:</h3>
+            <div class="endpoint">
+                <strong>GET</strong> <code>/v1/models</code><br>
+                <small>List available AI models</small>
+            </div>
+            <div class="endpoint">
+                <strong>POST</strong> <code>/v1/chat/completions</code><br>
+                <small>Create chat completion (supports streaming and tool calls)</small>
+            </div>
+            <div class="endpoint">
+                <strong>POST</strong> <code>/v1/responses</code><br>
+                <small>Create response (Responses API compatible)</small>
+            </div>
+            <div class="endpoint">
+                <strong>GET</strong> <code>/health</code><br>
+                <small>Health check endpoint</small>
+            </div>
+        </div>
+        
+        <div class="info">
+            <h3>🔐 Authentication:</h3>
+            <p>Use Bearer token authentication:</p>
+            <code>Authorization: Bearer YOUR_API_KEY</code>
+            <p><small>Default API key: <code>0000</code> (change via API_KEY environment variable)</small></p>
+        </div>
+        
+        <div class="info">
+            <h3>💻 Example Usage:</h3>
+            <pre><code>curl -X POST http://localhost:8002/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer 0000" \
+  -d '{
+    "model": "claude-sonnet-4.6-thinking",
+    "messages": [
+      {"role": "user", "content": "Plan first, then decide whether a tool is needed."}
+    ],
+    "stream": true
+  }'</code></pre>
+        </div>
+        
+        <div class="info">
+            <p><strong>Repository:</strong> <a href="https://github.com/cursor2api/cursor2api-go">cursor2api-go</a></p>
+            <p><strong>Documentation:</strong> OpenAI API compatible</p>
+        </div>
+    </div>
+</body>
+</html>`
+		docsContent = []byte(simpleHTML)
+	}
+
+	return &Handler{
+		config:        cfg,
+		cursorService: cursorService,
+		docsContent:   docsContent,
+		responseStore: services.NewResponseStore(0, 0),
+	}
+
+}
+
+// ListModels 列出可用模型
+func (h *Handler) ListModels(c *gin.Context) {
+	modelNames := h.config.GetModels()
+	modelList := make([]models.Model, 0, len(modelNames))
+
+	for _, modelID := range modelNames {
+		// 获取模型配置信息
+		modelConfig, exists := models.GetModelConfig(modelID)
+
+		model := models.Model{
+			ID:      modelID,
+			Object:  "model",
+			Created: time.Now().Unix(),
+			OwnedBy: "cursor2api",
+		}
+
+		// 如果找到模型配置，添加max_tokens和context_window信息
+		if exists {
+			model.MaxTokens = modelConfig.MaxTokens
+			model.ContextWindow = modelConfig.ContextWindow
+		}
+
+		modelList = append(modelList, model)
+	}
+
+	response := models.ModelsResponse{
+		Object: "list",
+		Data:   modelList,
+	}
+
+	c.JSON(http.StatusOK, response)
+}
+
+// ChatCompletions 处理聊天完成请求
+func (h *Handler) ChatCompletions(c *gin.Context) {
+	var request models.ChatCompletionRequest
+	if err := c.ShouldBindJSON(&request); err != nil {
+		logrus.WithError(err).Error("Failed to bind request")
+		c.JSON(http.StatusBadRequest, models.NewErrorResponse(
+			"Invalid request format",
+			"invalid_request_error",
+			"invalid_json",
+		))
+		return
+	}
+
+	// 验证模型
+	if !h.config.IsValidModel(request.Model) {
+		c.JSON(http.StatusBadRequest, models.NewErrorResponse(
+			"Invalid model specified",
+			"invalid_request_error",
+			"model_not_found",
+		))
+		return
+	}
+
+	// 验证消息
+	if len(request.Messages) == 0 {
+		c.JSON(http.StatusBadRequest, models.NewErrorResponse(
+			"Messages cannot be empty",
+			"invalid_request_error",
+			"missing_messages",
+		))
+		return
+	}
+
+	// 验证并调整max_tokens参数
+	request.MaxTokens = models.ValidateMaxTokens(request.Model, request.MaxTokens)
+
+	// 调用Cursor服务
+	// 根据是否流式返回不同响应
+	if request.Stream {
+		chatGenerator, err := h.cursorService.ChatCompletion(c.Request.Context(), &request)
+		if err != nil {
+			logrus.WithError(err).Error("Failed to create chat completion")
+			middleware.HandleError(c, err)
+			return
+		}
+		utils.SafeStreamWrapper(utils.StreamChatCompletion, c, chatGenerator, request.Model)
+	} else {
+		resp, err := h.cursorService.ChatCompletionNonStream(c.Request.Context(), &request)
+		if err != nil {
+			logrus.WithError(err).Error("Failed to create non-stream chat completion")
+			middleware.HandleError(c, err)
+			return
+		}
+		c.JSON(http.StatusOK, resp)
+	}
+}
+
+// Responses 处理 Responses API 请求
+func (h *Handler) Responses(c *gin.Context) {
+	var request models.ResponseRequest
+	if err := c.ShouldBindJSON(&request); err != nil {
+		logrus.WithError(err).Error("Failed to bind response request")
+		c.JSON(http.StatusBadRequest, models.NewErrorResponse(
+			"Invalid request format",
+			"invalid_request_error",
+			"invalid_json",
+		))
+		return
+	}
+
+	// 验证模型
+	if !h.config.IsValidModel(request.Model) {
+		c.JSON(http.StatusBadRequest, models.NewErrorResponse(
+			"Invalid model specified",
+			"invalid_request_error",
+			"model_not_found",
+		))
+		return
+	}
+
+	var previousMessages []models.Message
+	previousID := ""
+	if request.PreviousResponseID != nil {
+		previousID = strings.TrimSpace(*request.PreviousResponseID)
+	}
+	if previousID != "" {
+		stored, ok := h.responseStore.Get(previousID)
+		if !ok {
+			c.JSON(http.StatusBadRequest, models.NewErrorResponse(
+				"previous_response_id not found; include prior output items in input instead",
+				"invalid_request_error",
+				"previous_response_id",
+			))
+			return
+		}
+		previousMessages = stored
+	}
+
+	chatRequest, adapter, err := services.BuildChatCompletionRequestFromResponse(&request)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, models.NewErrorResponse(
+			err.Error(),
+			"invalid_request_error",
+			"invalid_input",
+		))
+		return
+	}
+
+	chatRequest.MaxTokens = models.ValidateMaxTokens(chatRequest.Model, chatRequest.MaxTokens)
+	if len(previousMessages) > 0 {
+		chatRequest.Messages = mergeStoredMessages(chatRequest.Messages, previousMessages)
+	}
+
+	if chatRequest.Stream {
+		chatGenerator, err := h.cursorService.ChatCompletion(c.Request.Context(), chatRequest)
+		if err != nil {
+			logrus.WithError(err).Error("Failed to create response stream")
+			middleware.HandleError(c, err)
+			return
+		}
+		responseID := utils.GenerateResponseID()
+		accumulator := newStreamAccumulator()
+		wrapped := teeChatGenerator(c.Request.Context(), chatGenerator, accumulator)
+		utils.SafeStreamWrapper(func(ctx *gin.Context, gen <-chan interface{}, model string) {
+			services.StreamResponse(ctx, gen, &request, adapter, responseID)
+		}, c, wrapped, chatRequest.Model)
+		if h.responseStore != nil && accumulator.okToStore() {
+			assistant := accumulator.message()
+			conversation := buildConversationForStore(chatRequest.Messages, assistant)
+			h.responseStore.Put(responseID, conversation)
+		}
+		return
+	}
+
+	resp, err := h.cursorService.ChatCompletionNonStream(c.Request.Context(), chatRequest)
+	if err != nil {
+		logrus.WithError(err).Error("Failed to create non-stream response")
+		middleware.HandleError(c, err)
+		return
+	}
+
+	if len(resp.Choices) == 0 {
+		c.JSON(http.StatusInternalServerError, models.NewErrorResponse(
+			"Empty response from upstream",
+			"internal_error",
+			"empty_response",
+		))
+		return
+	}
+	output, outputText := services.BuildResponseOutputFromMessage(resp.Choices[0].Message, adapter)
+	usage := services.BuildResponseUsage(resp.Usage)
+	response := services.BuildCompletedResponse(&request, output, outputText, usage)
+	if h.responseStore != nil {
+		conversation := buildConversationForStore(chatRequest.Messages, resp.Choices[0].Message)
+		h.responseStore.Put(response.ID, conversation)
+	}
+	c.JSON(http.StatusOK, response)
+}
+
+// ServeDocs 服务API文档页面
+func (h *Handler) ServeDocs(c *gin.Context) {
+	c.Data(http.StatusOK, "text/html; charset=utf-8", h.docsContent)
+}
+
+// Health 健康检查
+func (h *Handler) Health(c *gin.Context) {
+	c.JSON(http.StatusOK, gin.H{
+		"status":    "ok",
+		"timestamp": time.Now().Unix(),
+		"version":   "go-1.0.0",
+	})
+}

handlers/response_helpers.go

@@ -0,0 +1,126 @@
+package handlers
+
+import (
+	"context"
+	"github.com/libaxuan/cursor2api-go/models"
+	"strings"
+)
+
+type streamAccumulator struct {
+	content   strings.Builder
+	toolCalls []models.ToolCall
+	hadError  bool
+	aborted   bool
+	hasOutput bool
+}
+
+func newStreamAccumulator() *streamAccumulator {
+	return &streamAccumulator{}
+}
+
+func (a *streamAccumulator) feed(item interface{}) {
+	switch v := item.(type) {
+	case models.AssistantEvent:
+		switch v.Kind {
+		case models.AssistantEventText:
+			if v.Text != "" {
+				a.content.WriteString(v.Text)
+				a.hasOutput = true
+			}
+		case models.AssistantEventToolCall:
+			if v.ToolCall != nil {
+				a.toolCalls = append(a.toolCalls, *v.ToolCall)
+				a.hasOutput = true
+			}
+		case models.AssistantEventThinking:
+			return
+		}
+	case string:
+		if v != "" {
+			a.content.WriteString(v)
+			a.hasOutput = true
+		}
+	case error:
+		a.hadError = true
+	default:
+		return
+	}
+}
+
+func (a *streamAccumulator) markAborted() {
+	a.aborted = true
+}
+
+func (a *streamAccumulator) okToStore() bool {
+	return a.hasOutput && !a.hadError && !a.aborted
+}
+
+func (a *streamAccumulator) message() models.Message {
+	msg := models.Message{Role: "assistant"}
+	if a.content.Len() > 0 || len(a.toolCalls) == 0 {
+		msg.Content = a.content.String()
+	}
+	if len(a.toolCalls) > 0 {
+		msg.ToolCalls = a.toolCalls
+	}
+	return msg
+}
+
+func teeChatGenerator(ctx context.Context, in <-chan interface{}, acc *streamAccumulator) <-chan interface{} {
+	out := make(chan interface{}, 32)
+	go func() {
+		defer close(out)
+		for {
+			select {
+			case <-ctx.Done():
+				acc.markAborted()
+				return
+			case item, ok := <-in:
+				if !ok {
+					return
+				}
+				acc.feed(item)
+				select {
+				case out <- item:
+				case <-ctx.Done():
+					acc.markAborted()
+					return
+				}
+			}
+		}
+	}()
+	return out
+}
+
+func mergeStoredMessages(messages, stored []models.Message) []models.Message {
+	if len(stored) == 0 {
+		return messages
+	}
+
+	var system *models.Message
+	rest := messages
+	if len(messages) > 0 && strings.EqualFold(messages[0].Role, "system") {
+		system = &messages[0]
+		rest = messages[1:]
+	}
+
+	merged := make([]models.Message, 0, len(messages)+len(stored))
+	if system != nil {
+		merged = append(merged, *system)
+	}
+	merged = append(merged, stored...)
+	merged = append(merged, rest...)
+	return merged
+}
+
+func buildConversationForStore(messages []models.Message, assistant models.Message) []models.Message {
+	conversation := make([]models.Message, 0, len(messages)+1)
+	for _, msg := range messages {
+		if strings.EqualFold(msg.Role, "system") {
+			continue
+		}
+		conversation = append(conversation, msg)
+	}
+	conversation = append(conversation, assistant)
+	return conversation
+}

jscode/main.js

@@ -0,0 +1,128 @@
+global.cursor_config = {
+    currentScriptSrc: "$$currentScriptSrc$$",
+    fp:{
+        UNMASKED_VENDOR_WEBGL:"$$UNMASKED_VENDOR_WEBGL$$",
+        UNMASKED_RENDERER_WEBGL:"$$UNMASKED_RENDERER_WEBGL$$",
+        userAgent: "$$userAgent$$"
+    }
+}
+
+$$env_jscode$$
+
+let console_log = console.log;
+console.log = function () {
+
+}
+
+dtavm = console;
+delete __dirname;
+delete __filename;
+
+function proxy(obj, objname, type) {
+    function getMethodHandler(WatchName, target_obj) {
+        let methodhandler = {
+            apply(target, thisArg, argArray) {
+                if (this.target_obj) {
+                    thisArg = this.target_obj
+                }
+                let result = Reflect.apply(target, thisArg, argArray)
+                if (target.name !== "toString") {
+                    if (target.name === "addEventListener") {
+                        dtavm.log(`调用者 => [${WatchName}] 函数名 => [${target.name}], 传参 => [${argArray[0]}], 结果 => [${result}].`)
+                    } else if (WatchName === "window.console") {
+                    } else {
+                        dtavm.log(`调用者 => [${WatchName}] 函数名 => [${target.name}], 传参 => [${argArray}], 结果 => [${result}].`)
+                    }
+                } else {
+                    dtavm.log(`调用者 => [${WatchName}] 函数名 => [${target.name}], 传参 => [${argArray}], 结果 => [${result}].`)
+                }
+                return result
+            },
+            construct(target, argArray, newTarget) {
+                var result = Reflect.construct(target, argArray, newTarget)
+                dtavm.log(`调用者 => [${WatchName}] 构造函数名 => [${target.name}], 传参 => [${argArray}], 结果 => [${(result)}].`)
+                return result;
+            }
+        }
+        methodhandler.target_obj = target_obj
+        return methodhandler
+    }
+
+    function getObjhandler(WatchName) {
+        let handler = {
+            get(target, propKey, receiver) {
+                let result = target[propKey]
+                if (result instanceof Object) {
+                    if (typeof result === "function") {
+                        dtavm.log(`调用者 => [${WatchName}] 获取属性名 => [${propKey}] , 是个函数`)
+                        return new Proxy(result, getMethodHandler(WatchName, target))
+                    } else {
+                        dtavm.log(`调用者 => [${WatchName}] 获取属性名 => [${propKey}], 结果 => [${(result)}]`);
+                    }
+                    return new Proxy(result, getObjhandler(`${WatchName}.${propKey}`))
+                }
+                if (typeof (propKey) !== "symbol") {
+                    dtavm.log(`调用者 => [${WatchName}] 获取属性名 => [${propKey?.description ?? propKey}], 结果 => [${result}]`);
+                }
+                return result;
+            },
+            set(target, propKey, value, receiver) {
+                if (value instanceof Object) {
+                    dtavm.log(`调用者 => [${WatchName}] 设置属性名 => [${propKey}], 值为 => [${(value)}]`);
+                } else {
+                    dtavm.log(`调用者 => [${WatchName}] 设置属性名 => [${propKey}], 值为 => [${value}]`);
+                }
+                return Reflect.set(target, propKey, value, receiver);
+            },
+            has(target, propKey) {
+                var result = Reflect.has(target, propKey);
+                dtavm.log(`针对in操作符的代理has=> [${WatchName}] 有无属性名 => [${propKey}], 结果 => [${result}]`)
+                return result;
+            },
+            deleteProperty(target, propKey) {
+                var result = Reflect.deleteProperty(target, propKey);
+                dtavm.log(`拦截属性delete => [${WatchName}] 删除属性名 => [${propKey}], 结果 => [${result}]`)
+                return result;
+            },
+            defineProperty(target, propKey, attributes) {
+                var result = Reflect.defineProperty(target, propKey, attributes);
+                dtavm.log(`拦截对象define操作 => [${WatchName}] 待检索属性名 => [${propKey.toString()}] 属性描述 => [${(attributes)}], 结果 => [${result}]`)
+                // debugger
+                return result
+            },
+            getPrototypeOf(target) {
+                var result = Reflect.getPrototypeOf(target)
+                dtavm.log(`被代理的目标对象 => [${WatchName}] 代理结果 => [${(result)}]`)
+                return result;
+            },
+            setPrototypeOf(target, proto) {
+                dtavm.log(`被拦截的目标对象 => [${WatchName}] 对象新原型==> [${(proto)}]`)
+                return Reflect.setPrototypeOf(target, proto);
+            },
+            preventExtensions(target) {
+                dtavm.log(`方法用于设置preventExtensions => [${WatchName}] 防止扩展`)
+                return Reflect.preventExtensions(target);
+            },
+            isExtensible(target) {
+                var result = Reflect.isExtensible(target)
+                dtavm.log(`拦截对对象的isExtensible() => [${WatchName}] isExtensible, 返回值==> [${result}]`)
+                return result;
+            },
+        }
+        return handler;
+    }
+
+    if (type === "method") {
+        return new Proxy(obj, getMethodHandler(objname, obj));
+    }
+    return new Proxy(obj, getObjhandler(objname));
+}
+
+// window = proxy(window, 'window');
+global.document = window.document;
+
+$$cursor_jscode$$
+
+
+window.V_C[0]().then(value => console_log(JSON.stringify(value)));
+

main.go

@@ -0,0 +1,167 @@
+package main
+
+import (
+	"context"
+	"github.com/libaxuan/cursor2api-go/config"
+	"github.com/libaxuan/cursor2api-go/handlers"
+	"github.com/libaxuan/cursor2api-go/middleware"
+	"github.com/libaxuan/cursor2api-go/models"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func main() {
+	// 加载配置
+	cfg, err := config.LoadConfig()
+	if err != nil {
+		logrus.Fatalf("Failed to load config: %v", err)
+	}
+
+	// 设置日志级别和 GIN 模式（必须在创建路由器之前设置）
+	if cfg.Debug {
+		logrus.SetLevel(logrus.DebugLevel)
+		gin.SetMode(gin.DebugMode)
+	} else {
+		logrus.SetLevel(logrus.InfoLevel)
+		gin.SetMode(gin.ReleaseMode)
+	}
+
+	// 禁用 Gin 的调试信息输出
+	gin.DisableConsoleColor()
+
+	// 创建路由器（使用 gin.New() 而不是 gin.Default() 以避免默认日志）
+	router := gin.New()
+
+	// 添加中间件
+	router.Use(gin.Recovery())
+	router.Use(middleware.CORS())
+	router.Use(middleware.ErrorHandler())
+	// 只在 Debug 模式下启用 GIN 的日志
+	if cfg.Debug {
+		router.Use(gin.Logger())
+	}
+
+	// 创建处理器
+	handler := handlers.NewHandler(cfg)
+
+	// 注册路由
+	setupRoutes(router, handler)
+
+	// 创建HTTP服务器
+	server := &http.Server{
+		Addr:    fmt.Sprintf(":%d", cfg.Port),
+		Handler: router,
+	}
+
+	// 打印启动信息
+	printStartupBanner(cfg)
+
+	// 启动服务器的goroutine
+	go func() {
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logrus.Fatalf("Failed to start server: %v", err)
+		}
+	}()
+
+	// 等待中断信号以优雅关闭服务器
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+	logrus.Info("Shutting down server...")
+
+	// 给服务器5秒时间完成处理正在进行的请求
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := server.Shutdown(ctx); err != nil {
+		logrus.Fatalf("Server forced to shutdown: %v", err)
+	}
+
+	logrus.Info("Server exited")
+}
+
+func setupRoutes(router *gin.Engine, handler *handlers.Handler) {
+	// 健康检查
+	router.GET("/health", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"status": "ok",
+			"time":   time.Now().Unix(),
+		})
+	})
+
+	// API文档页面
+	router.GET("/", handler.ServeDocs)
+
+	// API v1路由组
+	v1 := router.Group("/v1")
+	{
+		// 模型列表
+		v1.GET("/models", middleware.AuthRequired(), handler.ListModels)
+
+		// 聊天完成
+		v1.POST("/chat/completions", middleware.AuthRequired(), handler.ChatCompletions)
+
+		// Responses API
+		v1.POST("/responses", middleware.AuthRequired(), handler.Responses)
+	}
+
+	// 静态文件服务（如果需要）
+	router.Static("/static", "./static")
+}
+
+// printStartupBanner 打印启动横幅
+func printStartupBanner(cfg *config.Config) {
+	banner := `
+╔══════════════════════════════════════════════════════════════╗
+║                      Cursor2API Server                       ║
+╚══════════════════════════════════════════════════════════════╝
+`
+	fmt.Println(banner)
+
+	fmt.Printf("🚀 服务地址:  http://localhost:%d\n", cfg.Port)
+	fmt.Printf("📚 API 文档:  http://localhost:%d/\n", cfg.Port)
+	fmt.Printf("💊 健康检查:  http://localhost:%d/health\n", cfg.Port)
+	fmt.Printf("🔑 API 密钥:  %s\n", maskAPIKey(cfg.APIKey))
+
+	modelList := cfg.GetModels()
+	fmt.Printf("\n🤖 支持模型 (%d 个):\n", len(modelList))
+
+	// 按类别分组显示模型
+	providers := make(map[string][]string)
+	for _, modelID := range modelList {
+		if config, exists := models.GetModelConfig(modelID); exists {
+			providers[config.Provider] = append(providers[config.Provider], modelID)
+		} else {
+			providers["Other"] = append(providers["Other"], modelID)
+		}
+	}
+
+	// 按Provider排序并显示
+	for _, provider := range []string{"Anthropic", "OpenAI", "Google", "Other"} {
+		if models, ok := providers[provider]; ok && len(models) > 0 {
+			fmt.Printf("   %s:  %s\n", provider, strings.Join(models, ", "))
+		}
+	}
+
+	if cfg.Debug {
+		fmt.Println("\n🐛 调试模式:  已启用")
+	}
+
+	fmt.Println("\n✨ 服务已启动，按 Ctrl+C 停止")
+	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+}
+
+// maskAPIKey 掩码 API 密钥，只显示前 4 位
+func maskAPIKey(key string) string {
+	if len(key) <= 4 {
+		return "****"
+	}
+	return key[:4] + "****"
+}

middleware/auth.go

@@ -0,0 +1,79 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package middleware
+
+import (
+	"github.com/libaxuan/cursor2api-go/models"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+// AuthRequired 认证中间件
+func AuthRequired() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		authHeader := c.GetHeader("Authorization")
+		
+		if authHeader == "" {
+			errorResponse := models.NewErrorResponse(
+				"Missing authorization header",
+				"authentication_error",
+				"missing_auth",
+			)
+			c.JSON(http.StatusUnauthorized, errorResponse)
+			c.Abort()
+			return
+		}
+
+		if !strings.HasPrefix(authHeader, "Bearer ") {
+			errorResponse := models.NewErrorResponse(
+				"Invalid authorization format. Expected 'Bearer <token>'",
+				"authentication_error",
+				"invalid_auth_format",
+			)
+			c.JSON(http.StatusUnauthorized, errorResponse)
+			c.Abort()
+			return
+		}
+
+		token := strings.TrimPrefix(authHeader, "Bearer ")
+		expectedToken := os.Getenv("API_KEY")
+		if expectedToken == "" {
+			expectedToken = "0000" // 默认值
+		}
+
+		if token != expectedToken {
+			errorResponse := models.NewErrorResponse(
+				"Invalid API key",
+				"authentication_error",
+				"invalid_api_key",
+			)
+			c.JSON(http.StatusUnauthorized, errorResponse)
+			c.Abort()
+			return
+		}
+
+		// 认证通过，继续处理请求
+		c.Next()
+	}
+}

middleware/cors.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+// CORS 跨域中间件
+func CORS() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 设置CORS头
+		c.Header("Access-Control-Allow-Origin", "*")
+		c.Header("Access-Control-Allow-Methods", "GET, POST, OPTIONS, PUT, DELETE")
+		c.Header("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With")
+		c.Header("Access-Control-Allow-Credentials", "true")
+		c.Header("Access-Control-Max-Age", "86400")
+
+		// 处理预检请求
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(200)
+			return
+		}
+
+		c.Next()
+	}
+}

middleware/error.go

@@ -0,0 +1,215 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package middleware
+
+import (
+	"github.com/libaxuan/cursor2api-go/models"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+// CursorWebError Cursor Web API错误
+type CursorWebError struct {
+	StatusCode int    `json:"status_code"`
+	Message    string `json:"message"`
+}
+
+// Error 实现error接口
+func (e *CursorWebError) Error() string {
+	return e.Message
+}
+
+// NewCursorWebError 创建新的CursorWebError
+func NewCursorWebError(statusCode int, message string) *CursorWebError {
+	return &CursorWebError{
+		StatusCode: statusCode,
+		Message:    message,
+	}
+}
+
+// ErrorHandler 全局错误处理中间件
+func ErrorHandler() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Next()
+
+		// 处理上下文中的错误
+		if len(c.Errors) > 0 {
+			err := c.Errors.Last().Err
+			handleError(c, err)
+		}
+	}
+}
+
+// HandleError 处理错误并返回适当的响应
+func HandleError(c *gin.Context, err error) {
+	handleError(c, err)
+}
+
+// handleError 内部错误处理逻辑
+func handleError(c *gin.Context, err error) {
+	// 如果已经写入了响应头，则不再处理
+	if c.Writer.Written() {
+		return
+	}
+
+	logrus.WithError(err).Error("API error occurred")
+
+	switch e := err.(type) {
+	case *CursorWebError:
+		// 处理Cursor Web错误
+		errorResponse := models.NewErrorResponse(
+			e.Message,
+			"cursor_web_error",
+			"",
+		)
+		c.JSON(e.StatusCode, errorResponse)
+
+	case *gin.Error:
+		// 处理Gin绑定错误
+		statusCode := http.StatusBadRequest
+		if e.Type == gin.ErrorTypePublic {
+			statusCode = http.StatusInternalServerError
+		}
+
+		errorResponse := models.NewErrorResponse(
+			e.Error(),
+			"validation_error",
+			"invalid_request",
+		)
+		c.JSON(statusCode, errorResponse)
+
+	case *RequestValidationError:
+		errorResponse := models.NewErrorResponse(
+			e.Message,
+			"invalid_request_error",
+			e.Code,
+		)
+		c.JSON(http.StatusBadRequest, errorResponse)
+
+	default:
+		// 处理其他错误
+		errorResponse := models.NewErrorResponse(
+			"Internal server error",
+			"internal_error",
+			"",
+		)
+		c.JSON(http.StatusInternalServerError, errorResponse)
+	}
+}
+
+// RequestValidationError 请求参数验证错误
+type RequestValidationError struct {
+	Message string `json:"message"`
+	Code    string `json:"code,omitempty"`
+}
+
+// Error 实现 error 接口
+func (e *RequestValidationError) Error() string {
+	return e.Message
+}
+
+// NewRequestValidationError 创建请求参数验证错误
+func NewRequestValidationError(message, code string) *RequestValidationError {
+	return &RequestValidationError{
+		Message: message,
+		Code:    code,
+	}
+}
+
+// RecoveryHandler 自定义恢复中间件
+func RecoveryHandler() gin.HandlerFunc {
+	return gin.CustomRecovery(func(c *gin.Context, recovered interface{}) {
+		logrus.WithField("panic", recovered).Error("Panic occurred")
+
+		if c.Writer.Written() {
+			return
+		}
+
+		errorResponse := models.NewErrorResponse(
+			"Internal server error",
+			"panic_error",
+			"",
+		)
+		c.JSON(http.StatusInternalServerError, errorResponse)
+	})
+}
+
+// ValidationError 验证错误
+type ValidationError struct {
+	Field   string `json:"field"`
+	Message string `json:"message"`
+}
+
+// MultipleValidationError 多个验证错误
+type MultipleValidationError struct {
+	Errors []ValidationError `json:"errors"`
+}
+
+// Error 实现error接口
+func (e *MultipleValidationError) Error() string {
+	return "validation failed"
+}
+
+// NewValidationError 创建验证错误
+func NewValidationError(field, message string) *ValidationError {
+	return &ValidationError{
+		Field:   field,
+		Message: message,
+	}
+}
+
+// AuthenticationError 认证错误
+type AuthenticationError struct {
+	Message string `json:"message"`
+}
+
+// Error 实现error接口
+func (e *AuthenticationError) Error() string {
+	return e.Message
+}
+
+// NewAuthenticationError 创建认证错误
+func NewAuthenticationError(message string) *AuthenticationError {
+	return &AuthenticationError{
+		Message: message,
+	}
+}
+
+// RateLimitError 限流错误
+type RateLimitError struct {
+	Message    string `json:"message"`
+	RetryAfter int    `json:"retry_after"`
+}
+
+// Error 实现error接口
+func (e *RateLimitError) Error() string {
+	return e.Message
+}
+
+// NewRateLimitError 创建限流错误
+func NewRateLimitError(message string, retryAfter int) *RateLimitError {
+	return &RateLimitError{
+		Message:    message,
+		RetryAfter: retryAfter,
+	}
+}

models/model_capabilities.go

@@ -0,0 +1,78 @@
+package models
+
+import "strings"
+
+// ThinkingModelSuffix 是自动派生的公开思维模型后缀
+const ThinkingModelSuffix = "-thinking"
+
+// ModelCapability 描述公开模型的能力视图
+type ModelCapability struct {
+	RequestedModel  string
+	BaseModel       string
+	ThinkingEnabled bool
+	ToolCapable     bool
+}
+
+// ResolveModelCapability 解析公开模型名到内部基础模型与能力开关
+func ResolveModelCapability(modelID string) ModelCapability {
+	return ModelCapability{
+		RequestedModel:  modelID,
+		BaseModel:       TrimThinkingModel(modelID),
+		ThinkingEnabled: IsThinkingModel(modelID),
+		ToolCapable:     true,
+	}
+}
+
+// ExpandModelList 将基础模型列表扩展为公开模型目录
+func ExpandModelList(baseModels []string) []string {
+	seen := make(map[string]struct{}, len(baseModels)*2)
+	result := make([]string, 0, len(baseModels)*2)
+
+	add := func(model string) {
+		if model == "" {
+			return
+		}
+		if _, exists := seen[model]; exists {
+			return
+		}
+		seen[model] = struct{}{}
+		result = append(result, model)
+	}
+
+	for _, model := range baseModels {
+		model = strings.TrimSpace(model)
+		if model == "" {
+			continue
+		}
+
+		add(model)
+		if !IsThinkingModel(model) {
+			add(ThinkingModelID(model))
+		}
+	}
+
+	return result
+}
+
+// IsThinkingModel 判断是否为公开 thinking 模型
+func IsThinkingModel(modelID string) bool {
+	return strings.HasSuffix(strings.TrimSpace(modelID), ThinkingModelSuffix)
+}
+
+// TrimThinkingModel 去除公开 thinking 模型后缀
+func TrimThinkingModel(modelID string) string {
+	modelID = strings.TrimSpace(modelID)
+	if IsThinkingModel(modelID) {
+		return strings.TrimSuffix(modelID, ThinkingModelSuffix)
+	}
+	return modelID
+}
+
+// ThinkingModelID 生成公开 thinking 模型名
+func ThinkingModelID(baseModel string) string {
+	baseModel = strings.TrimSpace(baseModel)
+	if baseModel == "" || IsThinkingModel(baseModel) {
+		return baseModel
+	}
+	return baseModel + ThinkingModelSuffix
+}

models/model_config.go

@@ -0,0 +1,99 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package models
+
+// ModelConfig 模型配置结构
+type ModelConfig struct {
+	ID            string `json:"id"`
+	Provider      string `json:"provider"`
+	MaxTokens     int    `json:"max_tokens"`
+	ContextWindow int    `json:"context_window"`
+	CursorModel   string `json:"cursor_model"`
+}
+
+// GetModelConfigs 获取所有基础模型配置
+func GetModelConfigs() map[string]ModelConfig {
+	return map[string]ModelConfig{
+		"claude-sonnet-4.6": {
+			ID:            "claude-sonnet-4.6",
+			Provider:      "Anthropic",
+			MaxTokens:     200000,
+			ContextWindow: 200000,
+			CursorModel:   "anthropic/claude-sonnet-4.6",
+		},
+	}
+}
+
+// GetModelConfig 获取指定模型的配置，支持公开 thinking 模型映射回基础模型
+func GetModelConfig(modelID string) (ModelConfig, bool) {
+	configs := GetModelConfigs()
+	baseModel := TrimThinkingModel(modelID)
+	config, exists := configs[baseModel]
+	if !exists {
+		return ModelConfig{}, false
+	}
+
+	config.ID = modelID
+	return config, true
+}
+
+// GetCursorModel 获取Cursor API使用的模型名称
+func GetCursorModel(modelID string) string {
+	if config, exists := GetModelConfig(modelID); exists && config.CursorModel != "" {
+		return config.CursorModel
+	}
+	return TrimThinkingModel(modelID)
+}
+
+// GetMaxTokensForModel 获取指定模型的最大token数
+func GetMaxTokensForModel(modelID string) int {
+	if config, exists := GetModelConfig(modelID); exists {
+		return config.MaxTokens
+	}
+	return 4096
+}
+
+// GetContextWindowForModel 获取指定模型的上下文窗口大小
+func GetContextWindowForModel(modelID string) int {
+	if config, exists := GetModelConfig(modelID); exists {
+		return config.ContextWindow
+	}
+	return 128000
+}
+
+// ValidateMaxTokens 验证并调整max_tokens参数
+func ValidateMaxTokens(modelID string, requestedMaxTokens *int) *int {
+	modelMaxTokens := GetMaxTokensForModel(modelID)
+
+	if requestedMaxTokens == nil {
+		return &modelMaxTokens
+	}
+
+	if *requestedMaxTokens > modelMaxTokens {
+		return &modelMaxTokens
+	}
+
+	if *requestedMaxTokens <= 0 {
+		return &modelMaxTokens
+	}
+
+	return requestedMaxTokens
+}

models/models.go

@@ -0,0 +1,388 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package models
+
+import (
+	"encoding/json"
+	"time"
+)
+
+// ChatCompletionRequest OpenAI聊天完成请求
+type ChatCompletionRequest struct {
+	Model       string          `json:"model" binding:"required"`
+	Messages    []Message       `json:"messages" binding:"required"`
+	Stream      bool            `json:"stream,omitempty"`
+	Temperature *float64        `json:"temperature,omitempty"`
+	MaxTokens   *int            `json:"max_tokens,omitempty"`
+	TopP        *float64        `json:"top_p,omitempty"`
+	Stop        []string        `json:"stop,omitempty"`
+	User        string          `json:"user,omitempty"`
+	Tools       []Tool          `json:"tools,omitempty"`
+	ToolChoice  json.RawMessage `json:"tool_choice,omitempty"`
+}
+
+// Message 消息结构
+type Message struct {
+	Role       string      `json:"role" binding:"required"`
+	Content    interface{} `json:"content"`
+	ToolCalls  []ToolCall  `json:"tool_calls,omitempty"`
+	ToolCallID string      `json:"tool_call_id,omitempty"`
+	Name       string      `json:"name,omitempty"`
+}
+
+// ContentPart 消息内容部分（用于多模态内容）
+type ContentPart struct {
+	Type string `json:"type"`
+	Text string `json:"text,omitempty"`
+	URL  string `json:"url,omitempty"`
+}
+
+// Tool OpenAI工具定义
+type Tool struct {
+	Type     string             `json:"type"`
+	Function FunctionDefinition `json:"function"`
+}
+
+// FunctionDefinition OpenAI函数定义
+type FunctionDefinition struct {
+	Name        string                 `json:"name"`
+	Description string                 `json:"description,omitempty"`
+	Parameters  map[string]interface{} `json:"parameters,omitempty"`
+}
+
+// ToolCall OpenAI工具调用
+type ToolCall struct {
+	ID       string       `json:"id"`
+	Type     string       `json:"type"`
+	Function FunctionCall `json:"function"`
+}
+
+// FunctionCall OpenAI函数调用信息
+type FunctionCall struct {
+	Name      string `json:"name"`
+	Arguments string `json:"arguments"`
+}
+
+// ToolChoiceObject OpenAI tool_choice 对象形式
+type ToolChoiceObject struct {
+	Type     string              `json:"type"`
+	Function *ToolChoiceFunction `json:"function,omitempty"`
+}
+
+// ToolChoiceFunction tool_choice 中的函数名
+type ToolChoiceFunction struct {
+	Name string `json:"name"`
+}
+
+// ChatCompletionResponse OpenAI聊天完成响应
+type ChatCompletionResponse struct {
+	ID      string   `json:"id"`
+	Object  string   `json:"object"`
+	Created int64    `json:"created"`
+	Model   string   `json:"model"`
+	Choices []Choice `json:"choices"`
+	Usage   Usage    `json:"usage"`
+}
+
+// ChatCompletionStreamResponse 流式响应
+type ChatCompletionStreamResponse struct {
+	ID      string         `json:"id"`
+	Object  string         `json:"object"`
+	Created int64          `json:"created"`
+	Model   string         `json:"model"`
+	Choices []StreamChoice `json:"choices"`
+}
+
+// Choice 选择结构
+type Choice struct {
+	Index        int     `json:"index"`
+	Message      Message `json:"message"`
+	FinishReason string  `json:"finish_reason"`
+}
+
+// StreamChoice 流式选择结构
+type StreamChoice struct {
+	Index        int         `json:"index"`
+	Delta        StreamDelta `json:"delta"`
+	FinishReason *string     `json:"finish_reason"`
+}
+
+// StreamDelta 流式增量数据
+type StreamDelta struct {
+	Role      string          `json:"role,omitempty"`
+	Content   string          `json:"content,omitempty"`
+	ToolCalls []ToolCallDelta `json:"tool_calls,omitempty"`
+}
+
+// ToolCallDelta 流式工具调用增量
+type ToolCallDelta struct {
+	Index    int                `json:"index"`
+	ID       string             `json:"id,omitempty"`
+	Type     string             `json:"type,omitempty"`
+	Function *FunctionCallDelta `json:"function,omitempty"`
+}
+
+// FunctionCallDelta 流式函数调用增量
+type FunctionCallDelta struct {
+	Name      string `json:"name,omitempty"`
+	Arguments string `json:"arguments,omitempty"`
+}
+
+// Usage 使用统计
+type Usage struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
+
+// Model 模型信息
+type Model struct {
+	ID            string `json:"id"`
+	Object        string `json:"object"`
+	Created       int64  `json:"created"`
+	OwnedBy       string `json:"owned_by"`
+	MaxTokens     int    `json:"max_tokens,omitempty"`
+	ContextWindow int    `json:"context_window,omitempty"`
+}
+
+// ModelsResponse 模型列表响应
+type ModelsResponse struct {
+	Object string  `json:"object"`
+	Data   []Model `json:"data"`
+}
+
+// ErrorResponse 错误响应
+type ErrorResponse struct {
+	Error ErrorDetail `json:"error"`
+}
+
+// ErrorDetail 错误详情
+type ErrorDetail struct {
+	Message string `json:"message"`
+	Type    string `json:"type"`
+	Code    string `json:"code,omitempty"`
+}
+
+// CursorMessage Cursor消息格式
+type CursorMessage struct {
+	Role  string       `json:"role"`
+	Parts []CursorPart `json:"parts"`
+}
+
+// CursorPart Cursor消息部分
+type CursorPart struct {
+	Type string `json:"type"`
+	Text string `json:"text"`
+}
+
+// CursorRequest Cursor请求格式
+type CursorRequest struct {
+	Context  []interface{}   `json:"context"`
+	Model    string          `json:"model"`
+	ID       string          `json:"id"`
+	Messages []CursorMessage `json:"messages"`
+	Trigger  string          `json:"trigger"`
+}
+
+// CursorEventData Cursor事件数据
+type CursorEventData struct {
+	Type            string                 `json:"type"`
+	Delta           string                 `json:"delta,omitempty"`
+	ErrorText       string                 `json:"errorText,omitempty"`
+	MessageMetadata *CursorMessageMetadata `json:"messageMetadata,omitempty"`
+}
+
+// CursorMessageMetadata Cursor消息元数据
+type CursorMessageMetadata struct {
+	Usage *CursorUsage `json:"usage,omitempty"`
+}
+
+// CursorUsage Cursor使用统计
+type CursorUsage struct {
+	InputTokens  int `json:"inputTokens"`
+	OutputTokens int `json:"outputTokens"`
+	TotalTokens  int `json:"totalTokens"`
+}
+
+// SSEEvent 服务器发送事件
+type SSEEvent struct {
+	Data  string `json:"data"`
+	Event string `json:"event,omitempty"`
+	ID    string `json:"id,omitempty"`
+}
+
+// CursorParseConfig 定义上游文本协议解析选项
+type CursorParseConfig struct {
+	TriggerSignal   string
+	ThinkingEnabled bool
+}
+
+// AssistantEventKind 助手输出事件类型
+type AssistantEventKind string
+
+const (
+	AssistantEventText     AssistantEventKind = "text"
+	AssistantEventThinking AssistantEventKind = "thinking"
+	AssistantEventToolCall AssistantEventKind = "tool_call"
+)
+
+// AssistantEvent 是内部流式解析事件
+type AssistantEvent struct {
+	Kind     AssistantEventKind
+	Text     string
+	Thinking string
+	ToolCall *ToolCall
+}
+
+// GetStringContent 获取消息的字符串内容
+func (m *Message) GetStringContent() string {
+	if m.Content == nil {
+		return ""
+	}
+
+	switch content := m.Content.(type) {
+	case string:
+		return content
+	case []ContentPart:
+		var text string
+		for _, part := range content {
+			if part.Type == "text" {
+				text += part.Text
+			}
+		}
+		return text
+	case []interface{}:
+		var text string
+		for _, item := range content {
+			if part, ok := item.(map[string]interface{}); ok {
+				if partType, exists := part["type"].(string); exists && partType == "text" {
+					if textContent, exists := part["text"].(string); exists {
+						text += textContent
+					}
+				}
+			}
+		}
+		return text
+	default:
+		if data, err := json.Marshal(content); err == nil {
+			return string(data)
+		}
+		return ""
+	}
+}
+
+// ToCursorMessages 将OpenAI消息转换为Cursor格式
+func ToCursorMessages(messages []Message, systemPromptInject string) []CursorMessage {
+	var result []CursorMessage
+
+	if systemPromptInject != "" {
+		if len(messages) > 0 && messages[0].Role == "system" {
+			content := messages[0].GetStringContent()
+			content += "\n" + systemPromptInject
+			result = append(result, CursorMessage{
+				Role: "system",
+				Parts: []CursorPart{
+					{Type: "text", Text: content},
+				},
+			})
+			messages = messages[1:]
+		} else {
+			result = append(result, CursorMessage{
+				Role: "system",
+				Parts: []CursorPart{
+					{Type: "text", Text: systemPromptInject},
+				},
+			})
+		}
+	} else if len(messages) > 0 && messages[0].Role == "system" {
+		result = append(result, CursorMessage{
+			Role: "system",
+			Parts: []CursorPart{
+				{Type: "text", Text: messages[0].GetStringContent()},
+			},
+		})
+		messages = messages[1:]
+	}
+
+	for _, msg := range messages {
+		if msg.Role == "" {
+			continue
+		}
+
+		result = append(result, CursorMessage{
+			Role: msg.Role,
+			Parts: []CursorPart{
+				{
+					Type: "text",
+					Text: msg.GetStringContent(),
+				},
+			},
+		})
+	}
+
+	return result
+}
+
+// NewChatCompletionResponse 创建聊天完成响应
+func NewChatCompletionResponse(id, model string, message Message, finishReason string, usage Usage) *ChatCompletionResponse {
+	return &ChatCompletionResponse{
+		ID:      id,
+		Object:  "chat.completion",
+		Created: time.Now().Unix(),
+		Model:   model,
+		Choices: []Choice{
+			{
+				Index:        0,
+				Message:      message,
+				FinishReason: finishReason,
+			},
+		},
+		Usage: usage,
+	}
+}
+
+// NewChatCompletionStreamResponse 创建流式响应
+func NewChatCompletionStreamResponse(id, model string, delta StreamDelta, finishReason *string) *ChatCompletionStreamResponse {
+	return &ChatCompletionStreamResponse{
+		ID:      id,
+		Object:  "chat.completion.chunk",
+		Created: time.Now().Unix(),
+		Model:   model,
+		Choices: []StreamChoice{
+			{
+				Index:        0,
+				Delta:        delta,
+				FinishReason: finishReason,
+			},
+		},
+	}
+}
+
+// NewErrorResponse 创建错误响应
+func NewErrorResponse(message, errorType, code string) *ErrorResponse {
+	return &ErrorResponse{
+		Error: ErrorDetail{
+			Message: message,
+			Type:    errorType,
+			Code:    code,
+		},
+	}
+}

models/models_test.go

@@ -0,0 +1,202 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package models
+
+import (
+	"testing"
+)
+
+func TestGetStringContent(t *testing.T) {
+	tests := []struct {
+		name     string
+		content  interface{}
+		expected string
+	}{
+		{
+			name:     "string content",
+			content:  "Hello world",
+			expected: "Hello world",
+		},
+		{
+			name: "array content",
+			content: []ContentPart{
+				{Type: "text", Text: "Hello"},
+				{Type: "text", Text: " world"},
+			},
+			expected: "Hello world",
+		},
+		{
+			name:     "empty array",
+			content:  []ContentPart{},
+			expected: "",
+		},
+		{
+			name:     "nil content",
+			content:  nil,
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			msg := &Message{Content: tt.content}
+			result := msg.GetStringContent()
+			if result != tt.expected {
+				t.Errorf("GetStringContent() = %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestToCursorMessages(t *testing.T) {
+	tests := []struct {
+		name             string
+		messages         []Message
+		systemPrompt     string
+		expectedLength   int
+		expectedFirstMsg string
+	}{
+		{
+			name: "no system prompt",
+			messages: []Message{
+				{Role: "user", Content: "Hello"},
+			},
+			systemPrompt:     "",
+			expectedLength:   1,
+			expectedFirstMsg: "Hello",
+		},
+		{
+			name: "with system prompt, no system message",
+			messages: []Message{
+				{Role: "user", Content: "Hello"},
+			},
+			systemPrompt:     "You are a helpful assistant",
+			expectedLength:   2,
+			expectedFirstMsg: "You are a helpful assistant",
+		},
+		{
+			name: "with system prompt, has system message",
+			messages: []Message{
+				{Role: "system", Content: "Be helpful"},
+				{Role: "user", Content: "Hello"},
+			},
+			systemPrompt:     "You are an AI",
+			expectedLength:   2,
+			expectedFirstMsg: "Be helpful\nYou are an AI",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ToCursorMessages(tt.messages, tt.systemPrompt)
+			if len(result) != tt.expectedLength {
+				t.Errorf("ToCursorMessages() length = %v, want %v", len(result), tt.expectedLength)
+			}
+			if len(result) > 0 && result[0].Parts[0].Text != tt.expectedFirstMsg {
+				t.Errorf("ToCursorMessages() first message = %v, want %v", result[0].Parts[0].Text, tt.expectedFirstMsg)
+			}
+		})
+	}
+}
+
+func TestNewChatCompletionResponse(t *testing.T) {
+	response := NewChatCompletionResponse(
+		"test-id",
+		"claude-sonnet-4.6",
+		Message{Role: "assistant", Content: "Hello world"},
+		"stop",
+		Usage{PromptTokens: 10, CompletionTokens: 5, TotalTokens: 15},
+	)
+
+	if response.ID != "test-id" {
+		t.Errorf("ID = %v, want test-id", response.ID)
+	}
+	if response.Model != "claude-sonnet-4.6" {
+		t.Errorf("Model = %v, want claude-sonnet-4.6", response.Model)
+	}
+	if response.Choices[0].Message.Content != "Hello world" {
+		t.Errorf("Content = %v, want Hello world", response.Choices[0].Message.Content)
+	}
+	if response.Usage.PromptTokens != 10 {
+		t.Errorf("PromptTokens = %v, want 10", response.Usage.PromptTokens)
+	}
+}
+
+func TestNewChatCompletionStreamResponse(t *testing.T) {
+	response := NewChatCompletionStreamResponse(
+		"test-id",
+		"claude-sonnet-4.6",
+		StreamDelta{Content: "Hello"},
+		stringPtr("stop"),
+	)
+
+	if response.ID != "test-id" {
+		t.Errorf("ID = %v, want test-id", response.ID)
+	}
+	if response.Choices[0].Delta.Content != "Hello" {
+		t.Errorf("Content = %v, want Hello", response.Choices[0].Delta.Content)
+	}
+	if response.Choices[0].FinishReason == nil || *response.Choices[0].FinishReason != "stop" {
+		t.Errorf("FinishReason = %v, want stop", response.Choices[0].FinishReason)
+	}
+}
+
+func TestResolveModelCapability(t *testing.T) {
+	capability := ResolveModelCapability("claude-sonnet-4.6-thinking")
+	if capability.BaseModel != "claude-sonnet-4.6" {
+		t.Fatalf("BaseModel = %v, want claude-sonnet-4.6", capability.BaseModel)
+	}
+	if !capability.ThinkingEnabled {
+		t.Fatalf("ThinkingEnabled = false, want true")
+	}
+}
+
+func TestExpandModelList(t *testing.T) {
+	models := ExpandModelList([]string{"claude-sonnet-4.6"})
+	expected := []string{"claude-sonnet-4.6", "claude-sonnet-4.6-thinking"}
+	if len(models) != len(expected) {
+		t.Fatalf("ExpandModelList() length = %v, want %v", len(models), len(expected))
+	}
+	for i := range expected {
+		if models[i] != expected[i] {
+			t.Fatalf("ExpandModelList()[%d] = %v, want %v", i, models[i], expected[i])
+		}
+	}
+}
+
+func TestNewErrorResponse(t *testing.T) {
+	response := NewErrorResponse("Test error", "test_error", "error_code")
+
+	if response.Error.Message != "Test error" {
+		t.Errorf("Message = %v, want Test error", response.Error.Message)
+	}
+	if response.Error.Type != "test_error" {
+		t.Errorf("Type = %v, want test_error", response.Error.Type)
+	}
+	if response.Error.Code != "error_code" {
+		t.Errorf("Code = %v, want error_code", response.Error.Code)
+	}
+}
+
+// Helper function
+func stringPtr(s string) *string {
+	return &s
+}

models/responses.go

@@ -0,0 +1,164 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package models
+
+import "encoding/json"
+
+// ResponseRequest OpenAI Responses API request
+type ResponseRequest struct {
+	Model              string                   `json:"model" binding:"required"`
+	Input              json.RawMessage          `json:"input,omitempty"`
+	Instructions       json.RawMessage          `json:"instructions,omitempty"`
+	Stream             bool                     `json:"stream,omitempty"`
+	Tools              []map[string]interface{} `json:"tools,omitempty"`
+	ToolChoice         json.RawMessage          `json:"tool_choice,omitempty"`
+	Temperature        *float64                 `json:"temperature,omitempty"`
+	TopP               *float64                 `json:"top_p,omitempty"`
+	MaxOutputTokens    *int                     `json:"max_output_tokens,omitempty"`
+	User               *string                  `json:"user,omitempty"`
+	PreviousResponseID *string                  `json:"previous_response_id,omitempty"`
+	Store              *bool                    `json:"store,omitempty"`
+	Metadata           map[string]string        `json:"metadata,omitempty"`
+	ParallelToolCalls  *bool                    `json:"parallel_tool_calls,omitempty"`
+	Text               json.RawMessage          `json:"text,omitempty"`
+	Reasoning          json.RawMessage          `json:"reasoning,omitempty"`
+	MaxToolCalls       *int                     `json:"max_tool_calls,omitempty"`
+	Background         *bool                    `json:"background,omitempty"`
+	Conversation       json.RawMessage          `json:"conversation,omitempty"`
+	Truncation         string                   `json:"truncation,omitempty"`
+}
+
+// Response OpenAI Responses API response
+type Response struct {
+	ID                 string                   `json:"id"`
+	Object             string                   `json:"object"`
+	CreatedAt          int64                    `json:"created_at"`
+	Status             string                   `json:"status"`
+	CompletedAt        *int64                   `json:"completed_at,omitempty"`
+	Background         *bool                    `json:"background,omitempty"`
+	Error              *ResponseError           `json:"error,omitempty"`
+	IncompleteDetails  *ResponseIncompleteInfo  `json:"incomplete_details,omitempty"`
+	Instructions       interface{}              `json:"instructions,omitempty"`
+	MaxOutputTokens    *int                     `json:"max_output_tokens,omitempty"`
+	MaxToolCalls       *int                     `json:"max_tool_calls,omitempty"`
+	Model              string                   `json:"model"`
+	Output             []interface{}            `json:"output"`
+	OutputText         string                   `json:"output_text,omitempty"`
+	ParallelToolCalls  bool                     `json:"parallel_tool_calls,omitempty"`
+	PreviousResponseID *string                  `json:"previous_response_id,omitempty"`
+	Reasoning          *ResponseReasoning       `json:"reasoning,omitempty"`
+	Store              *bool                    `json:"store,omitempty"`
+	Temperature        *float64                 `json:"temperature,omitempty"`
+	Text               interface{}              `json:"text,omitempty"`
+	ToolChoice         interface{}              `json:"tool_choice,omitempty"`
+	Tools              []map[string]interface{} `json:"tools,omitempty"`
+	TopP               *float64                 `json:"top_p,omitempty"`
+	Truncation         string                   `json:"truncation,omitempty"`
+	Usage              *ResponseUsage           `json:"usage,omitempty"`
+	User               *string                  `json:"user,omitempty"`
+	Metadata           map[string]string        `json:"metadata,omitempty"`
+}
+
+// ResponseError mirrors the Responses API error object
+type ResponseError struct {
+	Message string `json:"message"`
+	Type    string `json:"type,omitempty"`
+	Code    string `json:"code,omitempty"`
+}
+
+// ResponseIncompleteInfo mirrors the incomplete_details object
+type ResponseIncompleteInfo struct {
+	Reason string `json:"reason,omitempty"`
+}
+
+// ResponseReasoning mirrors the reasoning config on responses
+type ResponseReasoning struct {
+	Effort  *string     `json:"effort,omitempty"`
+	Summary interface{} `json:"summary,omitempty"`
+}
+
+// ResponseUsage mirrors the usage object on responses
+type ResponseUsage struct {
+	InputTokens         int                          `json:"input_tokens"`
+	OutputTokens        int                          `json:"output_tokens"`
+	TotalTokens         int                          `json:"total_tokens"`
+	OutputTokensDetails *ResponseOutputTokensDetails `json:"output_tokens_details,omitempty"`
+}
+
+// ResponseOutputTokensDetails mirrors output_tokens_details
+type ResponseOutputTokensDetails struct {
+	ReasoningTokens int `json:"reasoning_tokens,omitempty"`
+}
+
+// ResponseOutputTextContent is an output_text content part
+type ResponseOutputTextContent struct {
+	Type        string        `json:"type"`
+	Text        string        `json:"text"`
+	Annotations []interface{} `json:"annotations,omitempty"`
+	Logprobs    []interface{} `json:"logprobs,omitempty"`
+}
+
+// ResponseOutputMessage is a message output item
+type ResponseOutputMessage struct {
+	ID      string                      `json:"id"`
+	Type    string                      `json:"type"`
+	Status  string                      `json:"status,omitempty"`
+	Role    string                      `json:"role"`
+	Content []ResponseOutputTextContent `json:"content"`
+}
+
+// ResponseFunctionCall is a function_call output item
+type ResponseFunctionCall struct {
+	ID        string `json:"id"`
+	Type      string `json:"type"`
+	Status    string `json:"status,omitempty"`
+	CallID    string `json:"call_id"`
+	Name      string `json:"name"`
+	Arguments string `json:"arguments"`
+}
+
+// ResponseApplyPatchCall is an apply_patch_call output item
+type ResponseApplyPatchCall struct {
+	ID        string                 `json:"id"`
+	Type      string                 `json:"type"`
+	Status    string                 `json:"status,omitempty"`
+	CallID    string                 `json:"call_id"`
+	Operation map[string]interface{} `json:"operation"`
+}
+
+// ResponseShellCall is a shell_call output item
+type ResponseShellCall struct {
+	ID          string                 `json:"id"`
+	Type        string                 `json:"type"`
+	Status      string                 `json:"status,omitempty"`
+	CallID      string                 `json:"call_id"`
+	Action      map[string]interface{} `json:"action"`
+	Environment interface{}            `json:"environment,omitempty"`
+}
+
+// ResponseLocalShellCall is a local_shell_call output item
+type ResponseLocalShellCall struct {
+	ID     string                 `json:"id"`
+	Type   string                 `json:"type"`
+	Status string                 `json:"status,omitempty"`
+	CallID string                 `json:"call_id"`
+	Action map[string]interface{} `json:"action"`
+}

services/cursor.go

@@ -0,0 +1,575 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package services
+
+import (
+	"bufio"
+	"context"
+	"github.com/libaxuan/cursor2api-go/config"
+	"github.com/libaxuan/cursor2api-go/middleware"
+	"github.com/libaxuan/cursor2api-go/models"
+	"github.com/libaxuan/cursor2api-go/utils"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/imroc/req/v3"
+	"github.com/sirupsen/logrus"
+)
+
+const cursorAPIURL = "https://cursor.com/api/chat"
+
+// CursorService handles interactions with Cursor API.
+type CursorService struct {
+	config          *config.Config
+	client          *req.Client
+	mainJS          string
+	envJS           string
+	scriptCache     string
+	scriptCacheTime time.Time
+	scriptMutex     sync.RWMutex
+	headerGenerator *utils.HeaderGenerator
+}
+
+// NewCursorService creates a new service instance.
+func NewCursorService(cfg *config.Config) *CursorService {
+	mainJS, err := os.ReadFile(filepath.Join("jscode", "main.js"))
+	if err != nil {
+		logrus.Fatalf("failed to read jscode/main.js: %v", err)
+	}
+
+	envJS, err := os.ReadFile(filepath.Join("jscode", "env.js"))
+	if err != nil {
+		logrus.Fatalf("failed to read jscode/env.js: %v", err)
+	}
+
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		logrus.Warnf("failed to create cookie jar: %v", err)
+	}
+
+	client := req.C()
+	client.SetTimeout(time.Duration(cfg.Timeout) * time.Second)
+	client.ImpersonateChrome()
+	if jar != nil {
+		client.SetCookieJar(jar)
+	}
+
+	return &CursorService{
+		config:          cfg,
+		client:          client,
+		mainJS:          string(mainJS),
+		envJS:           string(envJS),
+		headerGenerator: utils.NewHeaderGenerator(),
+	}
+}
+
+// ChatCompletion creates a chat completion stream for the given request.
+func (s *CursorService) ChatCompletion(ctx context.Context, request *models.ChatCompletionRequest) (<-chan interface{}, error) {
+	buildResult, err := s.buildCursorRequest(request)
+	if err != nil {
+		return nil, err
+	}
+
+	jsonPayload, err := json.Marshal(buildResult.Payload)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal cursor payload: %w", err)
+	}
+
+	// 尝试最多2次
+	maxRetries := 2
+	for attempt := 1; attempt <= maxRetries; attempt++ {
+		xIsHuman, err := s.fetchXIsHuman(ctx)
+		if err != nil {
+			if attempt < maxRetries {
+				logrus.WithError(err).Warnf("Failed to fetch x-is-human token (attempt %d/%d), retrying...", attempt, maxRetries)
+				time.Sleep(time.Second * time.Duration(attempt)) // 指数退避
+				continue
+			}
+			return nil, err
+		}
+
+		// 添加详细的调试日志
+		headers := s.chatHeaders(xIsHuman)
+		logrus.WithFields(logrus.Fields{
+			"url":            cursorAPIURL,
+			"x-is-human":     xIsHuman[:50] + "...", // 只显示前50个字符
+			"payload_length": len(jsonPayload),
+			"model":          request.Model,
+			"attempt":        attempt,
+		}).Debug("Sending request to Cursor API")
+
+		resp, err := s.client.R().
+			SetContext(ctx).
+			SetHeaders(headers).
+			SetBody(jsonPayload).
+			DisableAutoReadResponse().
+			Post(cursorAPIURL)
+		if err != nil {
+			if attempt < maxRetries {
+				logrus.WithError(err).Warnf("Cursor request failed (attempt %d/%d), retrying...", attempt, maxRetries)
+				time.Sleep(time.Second * time.Duration(attempt))
+				continue
+			}
+			return nil, fmt.Errorf("cursor request failed: %w", err)
+		}
+
+		if resp.StatusCode != http.StatusOK {
+			body, _ := io.ReadAll(resp.Response.Body)
+			resp.Response.Body.Close()
+			message := strings.TrimSpace(string(body))
+
+			// 记录详细的错误信息
+			logrus.WithFields(logrus.Fields{
+				"status_code": resp.StatusCode,
+				"response":    message,
+				"headers":     resp.Header,
+				"attempt":     attempt,
+			}).Error("Cursor API returned non-OK status")
+
+			// 如果是 403 错误且还有重试机会,清除缓存并重试
+			if resp.StatusCode == http.StatusForbidden && attempt < maxRetries {
+				logrus.Warn("Received 403 Access Denied, refreshing browser fingerprint and clearing token cache...")
+
+				// 刷新浏览器指纹
+				s.headerGenerator.Refresh()
+				logrus.WithFields(logrus.Fields{
+					"platform":       s.headerGenerator.GetProfile().Platform,
+					"chrome_version": s.headerGenerator.GetProfile().ChromeVersion,
+				}).Debug("Refreshed browser fingerprint")
+
+				// 清除 token 缓存
+				s.scriptMutex.Lock()
+				s.scriptCache = ""
+				s.scriptCacheTime = time.Time{}
+				s.scriptMutex.Unlock()
+
+				time.Sleep(time.Second * time.Duration(attempt))
+				continue
+			}
+
+			if strings.Contains(message, "Attention Required! | Cloudflare") {
+				message = "Cloudflare 403"
+			}
+			return nil, middleware.NewCursorWebError(resp.StatusCode, message)
+		}
+
+		// 成功,返回结果
+		output := make(chan interface{}, 32)
+		go s.consumeSSE(ctx, resp.Response, output, buildResult.ParseConfig)
+		return output, nil
+	}
+
+	return nil, fmt.Errorf("failed after %d attempts", maxRetries)
+}
+
+type nonStreamCollectResult struct {
+	Message      models.Message
+	FinishReason string
+	Usage        models.Usage
+	ToolCalls    []models.ToolCall
+	Text         string
+}
+
+func (s *CursorService) collectNonStream(ctx context.Context, gen <-chan interface{}, modelName string) (nonStreamCollectResult, error) {
+	var fullContent strings.Builder
+	var usage models.Usage
+	toolCalls := make([]models.ToolCall, 0, 2)
+	finishReason := "stop"
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nonStreamCollectResult{}, ctx.Err()
+		case data, ok := <-gen:
+			if !ok {
+				msg := models.Message{Role: "assistant"}
+				if fullContent.Len() > 0 || len(toolCalls) == 0 {
+					msg.Content = fullContent.String()
+				}
+				if len(toolCalls) > 0 {
+					msg.ToolCalls = toolCalls
+					finishReason = "tool_calls"
+				}
+				return nonStreamCollectResult{
+					Message:      msg,
+					FinishReason: finishReason,
+					Usage:        usage,
+					ToolCalls:    toolCalls,
+					Text:         fullContent.String(),
+				}, nil
+			}
+
+			switch v := data.(type) {
+			case models.AssistantEvent:
+				switch v.Kind {
+				case models.AssistantEventText:
+					fullContent.WriteString(v.Text)
+				case models.AssistantEventToolCall:
+					if v.ToolCall != nil {
+						toolCalls = append(toolCalls, *v.ToolCall)
+					}
+				case models.AssistantEventThinking:
+					// thinking 对于 OpenAI chat.completion 的 message.content 不直接暴露
+					continue
+				}
+			case string:
+				fullContent.WriteString(v)
+			case models.Usage:
+				usage = v
+			case error:
+				return nonStreamCollectResult{}, v
+			default:
+				continue
+			}
+		}
+	}
+}
+
+func (s *CursorService) toolCallRequiredForRequest(request *models.ChatCompletionRequest) (bool, toolChoiceSpec, error) {
+	choice, err := parseToolChoice(request.ToolChoice)
+	if err != nil {
+		return false, toolChoiceSpec{}, err
+	}
+	if s.config != nil && s.config.KiloToolStrict && len(request.Tools) > 0 && choice.Mode == "auto" {
+		choice.Mode = "required"
+	}
+	if len(request.Tools) == 0 {
+		return false, choice, nil
+	}
+	return choice.Mode == "required" || choice.Mode == "function", choice, nil
+}
+
+func (s *CursorService) withToolRetrySystemMessage(request *models.ChatCompletionRequest, choice toolChoiceSpec) *models.ChatCompletionRequest {
+	cloned := *request
+	cloned.Messages = append([]models.Message(nil), request.Messages...)
+
+	var b strings.Builder
+	b.WriteString("TOOL USE REQUIRED.\n")
+	b.WriteString("Your next assistant message MUST be a tool call and must contain only the tool call in the exact bridge format. Do not output any natural language.\n")
+	if choice.Mode == "function" && strings.TrimSpace(choice.FunctionName) != "" {
+		b.WriteString(fmt.Sprintf("You MUST call function %q.\n", strings.TrimSpace(choice.FunctionName)))
+	} else {
+		b.WriteString("You MUST call at least one tool.\n")
+	}
+	b.WriteString("After receiving the tool result, you will provide the final answer.\n")
+
+	sys := models.Message{Role: "system", Content: b.String()}
+	cloned.Messages = append([]models.Message{sys}, cloned.Messages...)
+	return &cloned
+}
+
+// ChatCompletionNonStream runs a non-stream chat completion and returns a single OpenAI-compatible response.
+// It includes a Kilo-compatibility retry: if tools are provided and tool use is required but no tool_calls
+// are produced, it retries once with a stronger system instruction.
+func (s *CursorService) ChatCompletionNonStream(ctx context.Context, request *models.ChatCompletionRequest) (*models.ChatCompletionResponse, error) {
+	required, choice, err := s.toolCallRequiredForRequest(request)
+	if err != nil {
+		return nil, middleware.NewRequestValidationError(err.Error(), "invalid_tool_choice")
+	}
+
+	runOnce := func(req *models.ChatCompletionRequest) (nonStreamCollectResult, error) {
+		gen, err := s.ChatCompletion(ctx, req)
+		if err != nil {
+			return nonStreamCollectResult{}, err
+		}
+		return s.collectNonStream(ctx, gen, req.Model)
+	}
+
+	result, err := runOnce(request)
+	if err != nil {
+		return nil, err
+	}
+
+	if required && len(result.ToolCalls) == 0 {
+		retryReq := s.withToolRetrySystemMessage(request, choice)
+		retryResult, retryErr := runOnce(retryReq)
+		if retryErr == nil {
+			result = retryResult
+		} else {
+			logrus.WithError(retryErr).Warn("tool-required retry failed; returning first attempt")
+		}
+	}
+
+	respID := utils.GenerateChatCompletionID()
+	return models.NewChatCompletionResponse(respID, request.Model, result.Message, result.FinishReason, result.Usage), nil
+}
+
+func (s *CursorService) consumeSSE(ctx context.Context, resp *http.Response, output chan interface{}, parseConfig models.CursorParseConfig) {
+	defer close(output)
+	defer resp.Body.Close()
+
+	parser := utils.NewCursorProtocolParser(parseConfig)
+	scanner := bufio.NewScanner(resp.Body)
+	scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+
+	flushParser := func() {
+		for _, event := range parser.Finish() {
+			select {
+			case output <- event:
+			case <-ctx.Done():
+				return
+			}
+		}
+	}
+
+	for scanner.Scan() {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+
+		data := utils.ParseSSELine(scanner.Text())
+		if data == "" {
+			continue
+		}
+
+		if data == "[DONE]" {
+			flushParser()
+			return
+		}
+
+		var eventData models.CursorEventData
+		if err := json.Unmarshal([]byte(data), &eventData); err != nil {
+			logrus.WithError(err).Debugf("Failed to parse SSE data: %s", data)
+			continue
+		}
+
+		switch eventData.Type {
+		case "error":
+			if eventData.ErrorText != "" {
+				errResp := middleware.NewCursorWebError(http.StatusBadGateway, "cursor API error: "+eventData.ErrorText)
+				select {
+				case output <- errResp:
+				default:
+					logrus.WithError(errResp).Warn("failed to push SSE error to channel")
+				}
+				return
+			}
+		case "finish":
+			flushParser()
+			if eventData.MessageMetadata != nil && eventData.MessageMetadata.Usage != nil {
+				usage := models.Usage{
+					PromptTokens:     eventData.MessageMetadata.Usage.InputTokens,
+					CompletionTokens: eventData.MessageMetadata.Usage.OutputTokens,
+					TotalTokens:      eventData.MessageMetadata.Usage.TotalTokens,
+				}
+				select {
+				case output <- usage:
+				case <-ctx.Done():
+					return
+				}
+			}
+			return
+		default:
+			if eventData.Delta == "" {
+				continue
+			}
+			for _, event := range parser.Feed(eventData.Delta) {
+				select {
+				case output <- event:
+				case <-ctx.Done():
+					return
+				}
+			}
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		if errors.Is(err, context.Canceled) {
+			return
+		}
+		errResp := middleware.NewCursorWebError(http.StatusBadGateway, err.Error())
+		select {
+		case output <- errResp:
+		default:
+			logrus.WithError(err).Warn("failed to push SSE error to channel")
+		}
+		return
+	}
+
+	flushParser()
+}
+
+func (s *CursorService) fetchXIsHuman(ctx context.Context) (string, error) {
+	// 检查缓存
+	s.scriptMutex.RLock()
+	cached := s.scriptCache
+	lastFetch := s.scriptCacheTime
+	s.scriptMutex.RUnlock()
+
+	var scriptBody string
+	// 缓存有效期缩短到1分钟,避免 token 过期
+	if cached != "" && time.Since(lastFetch) < 1*time.Minute {
+		scriptBody = cached
+	} else {
+		resp, err := s.client.R().
+			SetContext(ctx).
+			SetHeaders(s.scriptHeaders()).
+			Get(s.config.ScriptURL)
+
+		if err != nil {
+			// 如果请求失败且有缓存，使用缓存
+			if cached != "" {
+				logrus.Warnf("Failed to fetch script, using cached version: %v", err)
+				scriptBody = cached
+			} else {
+				// 清除缓存并生成一个简单的token
+				s.scriptMutex.Lock()
+				s.scriptCache = ""
+				s.scriptCacheTime = time.Time{}
+				s.scriptMutex.Unlock()
+				// 生成一个简单的x-is-human token作为fallback
+				token := utils.GenerateRandomString(64)
+				logrus.Warnf("Failed to fetch script, generated fallback token")
+				return token, nil
+			}
+		} else if resp.StatusCode != http.StatusOK {
+			// 如果状态码异常且有缓存，使用缓存
+			if cached != "" {
+				logrus.Warnf("Script fetch returned status %d, using cached version", resp.StatusCode)
+				scriptBody = cached
+			} else {
+				// 清除缓存并生成一个简单的token
+				s.scriptMutex.Lock()
+				s.scriptCache = ""
+				s.scriptCacheTime = time.Time{}
+				s.scriptMutex.Unlock()
+				// 生成一个简单的x-is-human token作为fallback
+				token := utils.GenerateRandomString(64)
+				logrus.Warnf("Script fetch returned status %d, generated fallback token", resp.StatusCode)
+				return token, nil
+			}
+		} else {
+			scriptBody = string(resp.Bytes())
+			// 更新缓存
+			s.scriptMutex.Lock()
+			s.scriptCache = scriptBody
+			s.scriptCacheTime = time.Now()
+			s.scriptMutex.Unlock()
+		}
+	}
+
+	compiled := s.prepareJS(scriptBody)
+	value, err := utils.RunJS(compiled)
+	if err != nil {
+		// JS 执行失败时清除缓存并生成fallback token
+		s.scriptMutex.Lock()
+		s.scriptCache = ""
+		s.scriptCacheTime = time.Time{}
+		s.scriptMutex.Unlock()
+		token := utils.GenerateRandomString(64)
+		logrus.Warnf("Failed to execute JS, generated fallback token: %v", err)
+		return token, nil
+	}
+
+	logrus.WithField("length", len(value)).Debug("Fetched x-is-human token")
+
+	return value, nil
+}
+
+func (s *CursorService) prepareJS(cursorJS string) string {
+	replacer := strings.NewReplacer(
+		"$$currentScriptSrc$$", s.config.ScriptURL,
+		"$$UNMASKED_VENDOR_WEBGL$$", s.config.FP.UNMASKED_VENDOR_WEBGL,
+		"$$UNMASKED_RENDERER_WEBGL$$", s.config.FP.UNMASKED_RENDERER_WEBGL,
+		"$$userAgent$$", s.config.FP.UserAgent,
+	)
+
+	mainScript := replacer.Replace(s.mainJS)
+	mainScript = strings.Replace(mainScript, "$$env_jscode$$", s.envJS, 1)
+	mainScript = strings.Replace(mainScript, "$$cursor_jscode$$", cursorJS, 1)
+	return mainScript
+}
+
+func (s *CursorService) truncateCursorMessages(messages []models.CursorMessage) []models.CursorMessage {
+	if len(messages) == 0 || s.config.MaxInputLength <= 0 {
+		return messages
+	}
+
+	maxLength := s.config.MaxInputLength
+	total := 0
+	for _, msg := range messages {
+		total += cursorMessageTextLength(msg)
+	}
+
+	if total <= maxLength {
+		return messages
+	}
+
+	var result []models.CursorMessage
+	startIdx := 0
+
+	if strings.EqualFold(messages[0].Role, "system") {
+		result = append(result, messages[0])
+		maxLength -= cursorMessageTextLength(messages[0])
+		if maxLength < 0 {
+			maxLength = 0
+		}
+		startIdx = 1
+	}
+
+	current := 0
+	collected := make([]models.CursorMessage, 0, len(messages)-startIdx)
+	for i := len(messages) - 1; i >= startIdx; i-- {
+		msg := messages[i]
+		msgLen := cursorMessageTextLength(msg)
+		if msgLen == 0 {
+			continue
+		}
+		if current+msgLen > maxLength {
+			continue
+		}
+		collected = append(collected, msg)
+		current += msgLen
+	}
+
+	for i, j := 0, len(collected)-1; i < j; i, j = i+1, j-1 {
+		collected[i], collected[j] = collected[j], collected[i]
+	}
+
+	return append(result, collected...)
+}
+
+func cursorMessageTextLength(msg models.CursorMessage) int {
+	total := 0
+	for _, part := range msg.Parts {
+		total += len(part.Text)
+	}
+	return total
+}
+
+func (s *CursorService) chatHeaders(xIsHuman string) map[string]string {
+	return s.headerGenerator.GetChatHeaders(xIsHuman)
+}
+
+func (s *CursorService) scriptHeaders() map[string]string {
+	return s.headerGenerator.GetScriptHeaders()
+}

services/cursor_protocol.go

@@ -0,0 +1,369 @@
+package services
+
+import (
+	"bytes"
+	"github.com/libaxuan/cursor2api-go/middleware"
+	"github.com/libaxuan/cursor2api-go/models"
+	"github.com/libaxuan/cursor2api-go/utils"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+const thinkingHint = "Use <thinking>...</thinking> for hidden reasoning when it helps. Keep your final visible answer outside the thinking tags."
+
+type cursorBuildResult struct {
+	Payload     models.CursorRequest
+	ParseConfig models.CursorParseConfig
+}
+
+type toolChoiceSpec struct {
+	Mode         string
+	FunctionName string
+}
+
+func (s *CursorService) buildCursorRequest(request *models.ChatCompletionRequest) (cursorBuildResult, error) {
+	capability := models.ResolveModelCapability(request.Model)
+	toolChoice, err := parseToolChoice(request.ToolChoice)
+	if err != nil {
+		return cursorBuildResult{}, middleware.NewRequestValidationError(err.Error(), "invalid_tool_choice")
+	}
+
+	// Kilo Code 兼容：当上层编排器希望“必须用工具”时，即便 tool_choice=auto，
+	// 也可以通过环境变量强制要求至少一次工具调用，避免 MODEL_NO_TOOLS_USED 一类的上层报错。
+	if s.config != nil && s.config.KiloToolStrict && len(request.Tools) > 0 && toolChoice.Mode == "auto" {
+		toolChoice.Mode = "required"
+	}
+
+	if len(request.Tools) == 0 && toolChoice.Mode != "auto" && toolChoice.Mode != "none" {
+		return cursorBuildResult{}, middleware.NewRequestValidationError("tool_choice requires tools to be provided", "missing_tools")
+	}
+
+	if err := validateTools(request.Tools); err != nil {
+		return cursorBuildResult{}, middleware.NewRequestValidationError(err.Error(), "invalid_tools")
+	}
+
+	if toolChoice.FunctionName != "" && !toolExists(request.Tools, toolChoice.FunctionName) {
+		return cursorBuildResult{}, middleware.NewRequestValidationError(
+			fmt.Sprintf("tool_choice references unknown function %q", toolChoice.FunctionName),
+			"unknown_tool_choice_function",
+		)
+	}
+
+	hasToolHistory := messagesContainToolHistory(request.Messages)
+	toolProtocolEnabled := len(request.Tools) > 0 && toolChoice.Mode != "none"
+	triggerSignal := ""
+	if toolProtocolEnabled || hasToolHistory {
+		triggerSignal = "<<CALL_" + utils.GenerateRandomString(8) + ">>"
+	}
+
+	cursorMessages := buildCursorMessages(
+		request.Messages,
+		s.config.SystemPromptInject,
+		request.Tools,
+		toolChoice,
+		capability,
+		hasToolHistory,
+		triggerSignal,
+	)
+	cursorMessages = s.truncateCursorMessages(cursorMessages)
+
+	payload := models.CursorRequest{
+		Context:  []interface{}{},
+		Model:    models.GetCursorModel(request.Model),
+		ID:       utils.GenerateRandomString(16),
+		Messages: cursorMessages,
+		Trigger:  "submit-message",
+	}
+
+	return cursorBuildResult{
+		Payload: payload,
+		ParseConfig: models.CursorParseConfig{
+			TriggerSignal:   triggerSignal,
+			ThinkingEnabled: capability.ThinkingEnabled,
+		},
+	}, nil
+}
+
+func parseToolChoice(raw json.RawMessage) (toolChoiceSpec, error) {
+	if len(bytes.TrimSpace(raw)) == 0 || string(bytes.TrimSpace(raw)) == "null" {
+		return toolChoiceSpec{Mode: "auto"}, nil
+	}
+
+	var choiceString string
+	if err := json.Unmarshal(raw, &choiceString); err == nil {
+		switch choiceString {
+		case "auto", "none", "required":
+			return toolChoiceSpec{Mode: choiceString}, nil
+		default:
+			return toolChoiceSpec{}, fmt.Errorf("unsupported tool_choice value %q", choiceString)
+		}
+	}
+
+	var choiceObject models.ToolChoiceObject
+	if err := json.Unmarshal(raw, &choiceObject); err != nil {
+		return toolChoiceSpec{}, fmt.Errorf("tool_choice must be a string or function object")
+	}
+
+	if choiceObject.Type != "function" {
+		return toolChoiceSpec{}, fmt.Errorf("unsupported tool_choice type %q", choiceObject.Type)
+	}
+	if choiceObject.Function == nil || strings.TrimSpace(choiceObject.Function.Name) == "" {
+		return toolChoiceSpec{}, fmt.Errorf("tool_choice.function.name is required")
+	}
+
+	return toolChoiceSpec{
+		Mode:         "function",
+		FunctionName: strings.TrimSpace(choiceObject.Function.Name),
+	}, nil
+}
+
+func validateTools(tools []models.Tool) error {
+	seen := make(map[string]struct{}, len(tools))
+	for _, tool := range tools {
+		toolType := tool.Type
+		if toolType == "" {
+			toolType = "function"
+		}
+		if toolType != "function" {
+			return fmt.Errorf("unsupported tool type %q", tool.Type)
+		}
+
+		name := strings.TrimSpace(tool.Function.Name)
+		if name == "" {
+			return fmt.Errorf("tool function name is required")
+		}
+		if _, exists := seen[name]; exists {
+			return fmt.Errorf("duplicate tool function name %q", name)
+		}
+		seen[name] = struct{}{}
+	}
+	return nil
+}
+
+func toolExists(tools []models.Tool, name string) bool {
+	for _, tool := range tools {
+		if strings.TrimSpace(tool.Function.Name) == name {
+			return true
+		}
+	}
+	return false
+}
+
+func buildCursorMessages(
+	messages []models.Message,
+	systemPromptInject string,
+	tools []models.Tool,
+	toolChoice toolChoiceSpec,
+	capability models.ModelCapability,
+	hasToolHistory bool,
+	triggerSignal string,
+) []models.CursorMessage {
+	result := make([]models.CursorMessage, 0, len(messages)+1)
+	startIdx := 0
+	systemSegments := make([]string, 0, 3)
+
+	if len(messages) > 0 && strings.EqualFold(messages[0].Role, "system") {
+		if systemText := strings.TrimSpace(messages[0].GetStringContent()); systemText != "" {
+			systemSegments = append(systemSegments, systemText)
+		}
+		startIdx = 1
+	}
+	if inject := strings.TrimSpace(systemPromptInject); inject != "" {
+		systemSegments = append(systemSegments, inject)
+	}
+	if protocolText := strings.TrimSpace(buildProtocolPrompt(tools, toolChoice, capability.ThinkingEnabled, hasToolHistory, triggerSignal)); protocolText != "" {
+		systemSegments = append(systemSegments, protocolText)
+	}
+	if len(systemSegments) > 0 {
+		result = append(result, newCursorTextMessage("system", strings.Join(systemSegments, "\n\n")))
+	}
+
+	for _, msg := range messages[startIdx:] {
+		converted, ok := convertMessage(msg, capability.ThinkingEnabled, triggerSignal)
+		if !ok {
+			continue
+		}
+		result = append(result, converted)
+	}
+
+	return result
+}
+
+func buildProtocolPrompt(tools []models.Tool, toolChoice toolChoiceSpec, thinkingEnabled bool, hasToolHistory bool, triggerSignal string) string {
+	var sections []string
+
+	if len(tools) > 0 && triggerSignal != "" {
+		var builder strings.Builder
+		builder.WriteString("You may call external tools through the bridge below.\n")
+		builder.WriteString("When you need a tool, output exactly in this format with no markdown fences:\n")
+		builder.WriteString(triggerSignal)
+		builder.WriteString("\n<invoke name=\"tool_name\">{\"arg\":\"value\"}</invoke>\n")
+		builder.WriteString("Available tools:\n")
+		builder.WriteString(renderFunctionList(tools))
+
+		switch toolChoice.Mode {
+		case "required":
+			builder.WriteString("\nYou must call at least one tool before your final answer.")
+			builder.WriteString("\nIMPORTANT: Your next assistant message MUST be a tool call using the exact format above. Do not include any natural language text in that message.")
+		case "function":
+			builder.WriteString(fmt.Sprintf("\nYou must call the function %q before your final answer.", toolChoice.FunctionName))
+			builder.WriteString("\nIMPORTANT: Your next assistant message MUST be a tool call using the exact format above. Do not include any natural language text in that message.")
+		}
+
+		sections = append(sections, builder.String())
+	} else if hasToolHistory && triggerSignal != "" {
+		var builder strings.Builder
+		builder.WriteString("Previous assistant tool calls in this conversation are serialized in the following format:\n")
+		builder.WriteString(triggerSignal)
+		builder.WriteString("\n<invoke name=\"tool_name\">{\"arg\":\"value\"}</invoke>\n")
+		builder.WriteString("Previous tool results are serialized as <tool_result ...>...</tool_result>.\n")
+		builder.WriteString("Treat those tool transcripts as completed history. Do not emit a new tool call unless a current tool list is provided.")
+		sections = append(sections, builder.String())
+	}
+
+	if thinkingEnabled {
+		sections = append(sections, thinkingHint)
+	}
+
+	return strings.Join(sections, "\n\n")
+}
+
+func messagesContainToolHistory(messages []models.Message) bool {
+	for _, msg := range messages {
+		if len(msg.ToolCalls) > 0 {
+			return true
+		}
+		if strings.EqualFold(strings.TrimSpace(msg.Role), "tool") {
+			return true
+		}
+	}
+	return false
+}
+
+func renderFunctionList(tools []models.Tool) string {
+	var builder strings.Builder
+	builder.WriteString("<function_list>\n")
+	for _, tool := range tools {
+		schema := "{}"
+		if len(tool.Function.Parameters) > 0 {
+			if marshaled, err := json.MarshalIndent(tool.Function.Parameters, "", "  "); err == nil {
+				schema = string(marshaled)
+			}
+		}
+
+		builder.WriteString(fmt.Sprintf("<function name=\"%s\">\n", tool.Function.Name))
+		if desc := strings.TrimSpace(tool.Function.Description); desc != "" {
+			builder.WriteString(desc)
+			builder.WriteString("\n")
+		}
+		builder.WriteString("JSON Schema:\n")
+		builder.WriteString(schema)
+		builder.WriteString("\n</function>\n")
+	}
+	builder.WriteString("</function_list>")
+	return builder.String()
+}
+
+func convertMessage(msg models.Message, thinkingEnabled bool, triggerSignal string) (models.CursorMessage, bool) {
+	role := strings.TrimSpace(msg.Role)
+	if role == "" {
+		return models.CursorMessage{}, false
+	}
+
+	switch role {
+	case "tool":
+		return newCursorTextMessage("user", formatToolResult(msg)), true
+	case "assistant":
+		text := strings.TrimSpace(msg.GetStringContent())
+		segments := make([]string, 0, len(msg.ToolCalls)+1)
+		if text != "" {
+			segments = append(segments, text)
+		}
+		for _, toolCall := range msg.ToolCalls {
+			segments = append(segments, formatAssistantToolCall(toolCall, triggerSignal))
+		}
+		if len(segments) == 0 {
+			return models.CursorMessage{}, false
+		}
+		return newCursorTextMessage("assistant", strings.Join(segments, "\n\n")), true
+	case "user":
+		text := msg.GetStringContent()
+		if thinkingEnabled {
+			text = appendThinkingHint(text)
+		}
+		if strings.TrimSpace(text) == "" {
+			return models.CursorMessage{}, false
+		}
+		return newCursorTextMessage("user", text), true
+	default:
+		text := msg.GetStringContent()
+		if strings.TrimSpace(text) == "" {
+			return models.CursorMessage{}, false
+		}
+		return newCursorTextMessage(role, text), true
+	}
+}
+
+func appendThinkingHint(content string) string {
+	content = strings.TrimSpace(content)
+	if content == "" {
+		return thinkingHint
+	}
+	return content + "\n\n" + thinkingHint
+}
+
+func formatAssistantToolCall(toolCall models.ToolCall, triggerSignal string) string {
+	pieces := make([]string, 0, 2)
+	if triggerSignal != "" {
+		pieces = append(pieces, triggerSignal)
+	}
+
+	callType := toolCall.Type
+	if callType == "" {
+		callType = "function"
+	}
+	name := strings.TrimSpace(toolCall.Function.Name)
+	if name == "" {
+		name = "tool"
+	}
+
+	arguments := strings.TrimSpace(toolCall.Function.Arguments)
+	if arguments == "" {
+		arguments = "{}"
+	}
+
+	pieces = append(pieces, fmt.Sprintf("<invoke name=\"%s\">%s</invoke>", name, arguments))
+	return strings.Join(pieces, "\n")
+}
+
+func formatToolResult(msg models.Message) string {
+	content := msg.GetStringContent()
+	id := strings.TrimSpace(msg.ToolCallID)
+	name := strings.TrimSpace(msg.Name)
+
+	var builder strings.Builder
+	builder.WriteString("<tool_result")
+	if id != "" {
+		builder.WriteString(fmt.Sprintf(" id=\"%s\"", id))
+	}
+	if name != "" {
+		builder.WriteString(fmt.Sprintf(" name=\"%s\"", name))
+	}
+	builder.WriteString(">")
+	builder.WriteString(content)
+	builder.WriteString("</tool_result>")
+	return builder.String()
+}
+
+func newCursorTextMessage(role, text string) models.CursorMessage {
+	return models.CursorMessage{
+		Role: role,
+		Parts: []models.CursorPart{
+			{
+				Type: "text",
+				Text: text,
+			},
+		},
+	}
+}

services/cursor_protocol_test.go

@@ -0,0 +1,254 @@
+package services
+
+import (
+	"github.com/libaxuan/cursor2api-go/config"
+	"github.com/libaxuan/cursor2api-go/models"
+	"strings"
+	"testing"
+)
+
+func TestBuildCursorRequestEnablesToolProtocolForBaseModel(t *testing.T) {
+	service := &CursorService{
+		config: &config.Config{
+			SystemPromptInject: "Injected system prompt",
+			MaxInputLength:     10000,
+		},
+	}
+
+	request := &models.ChatCompletionRequest{
+		Model: "claude-sonnet-4.6",
+		Messages: []models.Message{
+			{Role: "user", Content: "What's the weather?"},
+		},
+		Tools: []models.Tool{
+			{
+				Type: "function",
+				Function: models.FunctionDefinition{
+					Name:        "get_weather",
+					Description: "Fetch current weather",
+					Parameters: map[string]interface{}{
+						"type": "object",
+					},
+				},
+			},
+		},
+	}
+
+	result, err := service.buildCursorRequest(request)
+	if err != nil {
+		t.Fatalf("buildCursorRequest() error = %v", err)
+	}
+
+	if result.Payload.Model != "anthropic/claude-sonnet-4.6" {
+		t.Fatalf("Payload.Model = %v, want anthropic/claude-sonnet-4.6", result.Payload.Model)
+	}
+	if result.ParseConfig.TriggerSignal == "" {
+		t.Fatalf("TriggerSignal should not be empty")
+	}
+	if result.ParseConfig.ThinkingEnabled {
+		t.Fatalf("ThinkingEnabled = true, want false")
+	}
+
+	systemText := result.Payload.Messages[0].Parts[0].Text
+	if !strings.Contains(systemText, "<function_list>") {
+		t.Fatalf("system prompt does not include function list: %s", systemText)
+	}
+	if strings.Contains(systemText, thinkingHint) {
+		t.Fatalf("system prompt should not include thinking hint for base model")
+	}
+}
+
+func TestBuildCursorRequestThinkingModelFormatsToolHistory(t *testing.T) {
+	service := &CursorService{
+		config: &config.Config{
+			MaxInputLength: 10000,
+		},
+	}
+
+	request := &models.ChatCompletionRequest{
+		Model: "claude-sonnet-4.6-thinking",
+		Messages: []models.Message{
+			{Role: "user", Content: "Plan first, then use tools."},
+			{
+				Role: "assistant",
+				ToolCalls: []models.ToolCall{
+					{
+						ID:   "call_1",
+						Type: "function",
+						Function: models.FunctionCall{
+							Name:      "lookup",
+							Arguments: `{"q":"revivalquant"}`,
+						},
+					},
+				},
+			},
+			{Role: "tool", ToolCallID: "call_1", Name: "lookup", Content: "Found result"},
+		},
+		Tools: []models.Tool{
+			{
+				Type: "function",
+				Function: models.FunctionDefinition{
+					Name: "lookup",
+				},
+			},
+		},
+	}
+
+	result, err := service.buildCursorRequest(request)
+	if err != nil {
+		t.Fatalf("buildCursorRequest() error = %v", err)
+	}
+
+	if result.ParseConfig.TriggerSignal == "" {
+		t.Fatalf("TriggerSignal should not be empty")
+	}
+	if !result.ParseConfig.ThinkingEnabled {
+		t.Fatalf("ThinkingEnabled = false, want true")
+	}
+	if result.Payload.Model != "anthropic/claude-sonnet-4.6" {
+		t.Fatalf("Payload.Model = %v, want anthropic/claude-sonnet-4.6", result.Payload.Model)
+	}
+
+	userText := result.Payload.Messages[1].Parts[0].Text
+	if !strings.Contains(userText, thinkingHint) {
+		t.Fatalf("user message should contain thinking hint, got: %s", userText)
+	}
+
+	assistantText := result.Payload.Messages[2].Parts[0].Text
+	if !strings.Contains(assistantText, result.ParseConfig.TriggerSignal) {
+		t.Fatalf("assistant tool history should include trigger signal, got: %s", assistantText)
+	}
+	if !strings.Contains(assistantText, `<invoke name="lookup">{"q":"revivalquant"}</invoke>`) {
+		t.Fatalf("assistant tool history missing invoke block, got: %s", assistantText)
+	}
+
+	toolText := result.Payload.Messages[3].Parts[0].Text
+	if !strings.Contains(toolText, `<tool_result id="call_1" name="lookup">Found result</tool_result>`) {
+		t.Fatalf("tool result history missing tool_result block, got: %s", toolText)
+	}
+}
+
+func TestBuildCursorRequestPreservesToolHistoryWithoutCurrentTools(t *testing.T) {
+	service := &CursorService{
+		config: &config.Config{
+			MaxInputLength: 10000,
+		},
+	}
+
+	request := &models.ChatCompletionRequest{
+		Model:      "claude-sonnet-4.6",
+		ToolChoice: []byte(`"none"`),
+		Messages: []models.Message{
+			{
+				Role: "assistant",
+				ToolCalls: []models.ToolCall{
+					{
+						ID:   "call_weather",
+						Type: "function",
+						Function: models.FunctionCall{
+							Name:      "get_weather",
+							Arguments: `{"city":"Beijing"}`,
+						},
+					},
+				},
+			},
+			{Role: "tool", ToolCallID: "call_weather", Name: "get_weather", Content: "Sunny"},
+			{Role: "user", Content: "Summarize the result."},
+		},
+	}
+
+	result, err := service.buildCursorRequest(request)
+	if err != nil {
+		t.Fatalf("buildCursorRequest() error = %v", err)
+	}
+
+	if result.ParseConfig.TriggerSignal == "" {
+		t.Fatalf("TriggerSignal should be kept for tool history replay")
+	}
+
+	systemText := result.Payload.Messages[0].Parts[0].Text
+	if !strings.Contains(systemText, "completed history") {
+		t.Fatalf("system prompt should explain historical tool transcript, got: %s", systemText)
+	}
+	if !strings.Contains(systemText, result.ParseConfig.TriggerSignal) {
+		t.Fatalf("system prompt should include trigger signal, got: %s", systemText)
+	}
+
+	assistantText := result.Payload.Messages[1].Parts[0].Text
+	if !strings.Contains(assistantText, result.ParseConfig.TriggerSignal) {
+		t.Fatalf("assistant history should preserve trigger signal, got: %s", assistantText)
+	}
+}
+
+func TestBuildCursorRequestAllowsToolChoiceNoneWithoutTools(t *testing.T) {
+	service := &CursorService{
+		config: &config.Config{
+			MaxInputLength: 10000,
+		},
+	}
+
+	request := &models.ChatCompletionRequest{
+		Model:      "claude-sonnet-4.6",
+		ToolChoice: []byte(`"none"`),
+		Messages: []models.Message{
+			{Role: "user", Content: "Hello"},
+		},
+	}
+
+	result, err := service.buildCursorRequest(request)
+	if err != nil {
+		t.Fatalf("buildCursorRequest() error = %v", err)
+	}
+	if result.ParseConfig.TriggerSignal != "" {
+		t.Fatalf("TriggerSignal = %q, want empty for plain chat", result.ParseConfig.TriggerSignal)
+	}
+	if len(result.Payload.Messages) != 1 {
+		t.Fatalf("payload message count = %d, want 1", len(result.Payload.Messages))
+	}
+}
+
+func TestBuildCursorRequestCountsSerializedToolCallsInMaxInputLength(t *testing.T) {
+	service := &CursorService{
+		config: &config.Config{
+			MaxInputLength: 20,
+		},
+	}
+
+	request := &models.ChatCompletionRequest{
+		Model: "claude-sonnet-4.6",
+		Messages: []models.Message{
+			{
+				Role: "assistant",
+				ToolCalls: []models.ToolCall{
+					{
+						ID:   "call_1",
+						Type: "function",
+						Function: models.FunctionCall{
+							Name:      "lookup",
+							Arguments: `{"payload":"1234567890123456789012345678901234567890"}`,
+						},
+					},
+				},
+			},
+			{Role: "user", Content: "Short"},
+		},
+	}
+
+	result, err := service.buildCursorRequest(request)
+	if err != nil {
+		t.Fatalf("buildCursorRequest() error = %v", err)
+	}
+
+	for _, msg := range result.Payload.Messages {
+		if strings.Contains(msg.Parts[0].Text, `"payload":"1234567890123456789012345678901234567890"`) {
+			t.Fatalf("serialized tool call arguments should be removed by truncation, payload still contains long tool json: %#v", result.Payload.Messages)
+		}
+	}
+	totalLength := 0
+	for _, msg := range result.Payload.Messages {
+		totalLength += len(msg.Parts[0].Text)
+	}
+	if totalLength == 0 {
+		t.Fatalf("truncation should preserve at least one message")
+	}
+}

services/response_adapter.go

@@ -0,0 +1,664 @@
+package services
+
+import (
+	"bytes"
+	"github.com/libaxuan/cursor2api-go/models"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// ResponseToolAdapter records tool mappings for Responses API bridging.
+type ResponseToolAdapter struct {
+	ToolTypesByName  map[string]string
+	ShellEnvironment interface{}
+}
+
+// BuildChatCompletionRequestFromResponse converts a Responses API request into a chat/completions request.
+func BuildChatCompletionRequestFromResponse(req *models.ResponseRequest) (*models.ChatCompletionRequest, *ResponseToolAdapter, error) {
+	instructionMessages, err := parseResponseMessages(req.Instructions, "system")
+	if err != nil {
+		return nil, nil, err
+	}
+
+	inputMessages, err := parseResponseMessages(req.Input, "user")
+	if err != nil {
+		return nil, nil, err
+	}
+
+	messages := append(instructionMessages, inputMessages...)
+	if len(messages) == 0 {
+		return nil, nil, fmt.Errorf("input is required")
+	}
+
+	tools, adapter, err := convertResponseTools(req.Tools)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	toolChoice, err := convertResponseToolChoice(req.ToolChoice)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	chatReq := &models.ChatCompletionRequest{
+		Model:       req.Model,
+		Messages:    messages,
+		Stream:      req.Stream,
+		Temperature: req.Temperature,
+		MaxTokens:   req.MaxOutputTokens,
+		TopP:        req.TopP,
+		Tools:       tools,
+		ToolChoice:  toolChoice,
+	}
+
+	if req.User != nil {
+		chatReq.User = *req.User
+	}
+
+	return chatReq, adapter, nil
+}
+
+func parseResponseMessages(raw json.RawMessage, defaultRole string) ([]models.Message, error) {
+	trimmed := bytes.TrimSpace(raw)
+	if len(trimmed) == 0 || string(trimmed) == "null" {
+		return nil, nil
+	}
+
+	switch trimmed[0] {
+	case '"':
+		var text string
+		if err := json.Unmarshal(trimmed, &text); err != nil {
+			return nil, fmt.Errorf("invalid input text: %w", err)
+		}
+		if strings.TrimSpace(text) == "" {
+			return nil, nil
+		}
+		return []models.Message{{Role: defaultRole, Content: text}}, nil
+	case '{':
+		var obj map[string]interface{}
+		if err := json.Unmarshal(trimmed, &obj); err != nil {
+			return nil, fmt.Errorf("invalid input object: %w", err)
+		}
+		msgs := parseResponseItem(obj, defaultRole)
+		return msgs, nil
+	case '[':
+		var arr []interface{}
+		if err := json.Unmarshal(trimmed, &arr); err != nil {
+			return nil, fmt.Errorf("invalid input array: %w", err)
+		}
+		var result []models.Message
+		for _, item := range arr {
+			switch typed := item.(type) {
+			case map[string]interface{}:
+				result = append(result, parseResponseItem(typed, defaultRole)...)
+			case string:
+				if strings.TrimSpace(typed) != "" {
+					result = append(result, models.Message{Role: defaultRole, Content: typed})
+				}
+			}
+		}
+		return result, nil
+	default:
+		return nil, fmt.Errorf("unsupported input format")
+	}
+}
+
+func parseResponseItem(item map[string]interface{}, defaultRole string) []models.Message {
+	itemType := strings.TrimSpace(asString(item["type"]))
+	role := strings.TrimSpace(asString(item["role"]))
+
+	if itemType == "" && role != "" {
+		itemType = "message"
+	}
+
+	switch itemType {
+	case "message":
+		if role == "" {
+			role = defaultRole
+		}
+		role = mapRole(role)
+		content := extractContentText(item["content"])
+		if strings.TrimSpace(content) == "" {
+			return nil
+		}
+		return []models.Message{{Role: role, Content: content}}
+	case "function_call":
+		callID := firstNonEmpty(asString(item["call_id"]), asString(item["id"]))
+		name := strings.TrimSpace(asString(item["name"]))
+		args := strings.TrimSpace(stringifyJSON(item["arguments"]))
+		if args == "" {
+			args = "{}"
+		}
+		toolCall := models.ToolCall{
+			ID:   callID,
+			Type: "function",
+			Function: models.FunctionCall{
+				Name:      name,
+				Arguments: args,
+			},
+		}
+		return []models.Message{{Role: "assistant", ToolCalls: []models.ToolCall{toolCall}}}
+	case "tool_call":
+		callID := firstNonEmpty(asString(item["call_id"]), asString(item["id"]))
+		name := strings.TrimSpace(asString(item["tool_name"]))
+		if name == "" {
+			name = strings.TrimSpace(asString(item["name"]))
+		}
+		if name == "" {
+			return nil
+		}
+		args := strings.TrimSpace(stringifyJSON(item["arguments"]))
+		if args == "" {
+			if action, ok := item["action"]; ok {
+				args = wrapJSONArg("action", action)
+			} else if input := strings.TrimSpace(asString(item["input"])); input != "" {
+				args = wrapInputAsJSON(input)
+			} else {
+				args = "{}"
+			}
+		}
+		toolCall := models.ToolCall{
+			ID:   callID,
+			Type: "function",
+			Function: models.FunctionCall{
+				Name:      name,
+				Arguments: args,
+			},
+		}
+		return []models.Message{{Role: "assistant", ToolCalls: []models.ToolCall{toolCall}}}
+	case "custom_tool_call":
+		callID := firstNonEmpty(asString(item["call_id"]), asString(item["id"]))
+		name := strings.TrimSpace(asString(item["name"]))
+		input := asString(item["input"])
+		args := wrapInputAsJSON(input)
+		toolCall := models.ToolCall{
+			ID:   callID,
+			Type: "function",
+			Function: models.FunctionCall{
+				Name:      name,
+				Arguments: args,
+			},
+		}
+		return []models.Message{{Role: "assistant", ToolCalls: []models.ToolCall{toolCall}}}
+	case "apply_patch_call":
+		callID := firstNonEmpty(asString(item["call_id"]), asString(item["id"]))
+		op := item["operation"]
+		args := wrapJSONArg("operation", op)
+		toolCall := models.ToolCall{
+			ID:   callID,
+			Type: "function",
+			Function: models.FunctionCall{
+				Name:      "apply_patch",
+				Arguments: args,
+			},
+		}
+		return []models.Message{{Role: "assistant", ToolCalls: []models.ToolCall{toolCall}}}
+	case "shell_call":
+		callID := firstNonEmpty(asString(item["call_id"]), asString(item["id"]))
+		action := item["action"]
+		args := wrapJSONArg("action", action)
+		toolCall := models.ToolCall{
+			ID:   callID,
+			Type: "function",
+			Function: models.FunctionCall{
+				Name:      "shell",
+				Arguments: args,
+			},
+		}
+		return []models.Message{{Role: "assistant", ToolCalls: []models.ToolCall{toolCall}}}
+	case "local_shell_call":
+		callID := firstNonEmpty(asString(item["call_id"]), asString(item["id"]))
+		action := item["action"]
+		args := ""
+		if action != nil {
+			args = wrapJSONArg("action", action)
+		}
+		if args == "" {
+			args = strings.TrimSpace(stringifyJSON(item["arguments"]))
+		}
+		if args == "" {
+			args = "{}"
+		}
+		toolCall := models.ToolCall{
+			ID:   callID,
+			Type: "function",
+			Function: models.FunctionCall{
+				Name:      "local_shell",
+				Arguments: args,
+			},
+		}
+		return []models.Message{{Role: "assistant", ToolCalls: []models.ToolCall{toolCall}}}
+	case "function_call_output":
+		callID := asString(item["call_id"])
+		output := normalizeToolOutput(item["output"])
+		if strings.TrimSpace(output) == "" {
+			return nil
+		}
+		return []models.Message{{Role: "tool", Content: output, ToolCallID: callID}}
+	case "apply_patch_call_output":
+		callID := asString(item["call_id"])
+		output := normalizeToolOutput(item["output"])
+		if strings.TrimSpace(output) == "" {
+			return nil
+		}
+		return []models.Message{{Role: "tool", Content: output, ToolCallID: callID, Name: "apply_patch"}}
+	case "shell_call_output":
+		callID := asString(item["call_id"])
+		output := normalizeToolOutput(item["output"])
+		if strings.TrimSpace(output) == "" {
+			return nil
+		}
+		return []models.Message{{Role: "tool", Content: output, ToolCallID: callID, Name: "shell"}}
+	case "local_shell_call_output":
+		callID := asString(item["call_id"])
+		output := normalizeToolOutput(item["output"])
+		if strings.TrimSpace(output) == "" {
+			return nil
+		}
+		return []models.Message{{Role: "tool", Content: output, ToolCallID: callID, Name: "local_shell"}}
+	case "tool_call_output":
+		callID := asString(item["call_id"])
+		output := normalizeToolOutput(item["output"])
+		if strings.TrimSpace(output) == "" {
+			return nil
+		}
+		name := strings.TrimSpace(asString(item["tool_name"]))
+		if name == "" {
+			name = strings.TrimSpace(asString(item["name"]))
+		}
+		return []models.Message{{Role: "tool", Content: output, ToolCallID: callID, Name: name}}
+	default:
+		return nil
+	}
+}
+
+func convertResponseTools(rawTools []map[string]interface{}) ([]models.Tool, *ResponseToolAdapter, error) {
+	adapter := &ResponseToolAdapter{ToolTypesByName: make(map[string]string)}
+	tools := make([]models.Tool, 0, len(rawTools))
+
+	for _, raw := range rawTools {
+		toolType := strings.TrimSpace(asString(raw["type"]))
+		if toolType == "" {
+			continue
+		}
+
+		switch toolType {
+		case "function":
+			name := strings.TrimSpace(asString(raw["name"]))
+			if name == "" {
+				return nil, nil, fmt.Errorf("function tool name is required")
+			}
+			desc := strings.TrimSpace(asString(raw["description"]))
+			params, _ := raw["parameters"].(map[string]interface{})
+			tools = append(tools, models.Tool{
+				Type: "function",
+				Function: models.FunctionDefinition{
+					Name:        name,
+					Description: desc,
+					Parameters:  params,
+				},
+			})
+		case "apply_patch":
+			tools = append(tools, applyPatchToolDefinition())
+			adapter.ToolTypesByName["apply_patch"] = "apply_patch"
+		case "shell":
+			tools = append(tools, shellToolDefinition())
+			adapter.ToolTypesByName["shell"] = "shell"
+			if env, ok := raw["environment"]; ok {
+				adapter.ShellEnvironment = env
+			}
+		case "local_shell":
+			tools = append(tools, localShellToolDefinition())
+			adapter.ToolTypesByName["local_shell"] = "local_shell"
+		default:
+			// Fallback: expose built-in tools as custom function tools for compatibility.
+			name := toolType
+			desc := strings.TrimSpace(asString(raw["description"]))
+			if desc == "" {
+				desc = fmt.Sprintf("Built-in tool: %s (proxied).", toolType)
+			}
+			tools = append(tools, models.Tool{
+				Type: "function",
+				Function: models.FunctionDefinition{
+					Name:        name,
+					Description: desc,
+					Parameters: map[string]interface{}{
+						"type":                 "object",
+						"additionalProperties": true,
+					},
+				},
+			})
+		}
+	}
+
+	return tools, adapter, nil
+}
+
+func applyPatchToolDefinition() models.Tool {
+	return models.Tool{
+		Type: "function",
+		Function: models.FunctionDefinition{
+			Name:        "apply_patch",
+			Description: "Apply a patch to the local workspace. Return JSON with operation {type, path, diff}.",
+			Parameters: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"operation": map[string]interface{}{
+						"type": "object",
+						"properties": map[string]interface{}{
+							"type": map[string]interface{}{
+								"type": "string",
+								"enum": []string{"create_file", "update_file", "delete_file"},
+							},
+							"path": map[string]interface{}{
+								"type": "string",
+							},
+							"diff": map[string]interface{}{
+								"type": "string",
+							},
+						},
+						"required": []string{"type", "path"},
+					},
+				},
+				"required": []string{"operation"},
+			},
+		},
+	}
+}
+
+func shellToolDefinition() models.Tool {
+	return models.Tool{
+		Type: "function",
+		Function: models.FunctionDefinition{
+			Name:        "shell",
+			Description: "Run shell commands locally. Return JSON with commands (array), timeout_ms, max_output_length.",
+			Parameters: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"commands": map[string]interface{}{
+						"type":  "array",
+						"items": map[string]interface{}{"type": "string"},
+					},
+					"timeout_ms": map[string]interface{}{
+						"type": "integer",
+					},
+					"max_output_length": map[string]interface{}{
+						"type": "integer",
+					},
+					"action": map[string]interface{}{
+						"type": "object",
+						"properties": map[string]interface{}{
+							"commands": map[string]interface{}{
+								"type":  "array",
+								"items": map[string]interface{}{"type": "string"},
+							},
+							"timeout_ms": map[string]interface{}{
+								"type": "integer",
+							},
+							"max_output_length": map[string]interface{}{
+								"type": "integer",
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func localShellToolDefinition() models.Tool {
+	return models.Tool{
+		Type: "function",
+		Function: models.FunctionDefinition{
+			Name:        "local_shell",
+			Description: "Run local shell commands. Return JSON with command, timeout_ms, working_directory, env, max_output_length.",
+			Parameters: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"command": map[string]interface{}{
+						"type": "string",
+					},
+					"commands": map[string]interface{}{
+						"type":  "array",
+						"items": map[string]interface{}{"type": "string"},
+					},
+					"timeout_ms": map[string]interface{}{
+						"type": "integer",
+					},
+					"working_directory": map[string]interface{}{
+						"type": "string",
+					},
+					"env": map[string]interface{}{
+						"type":                 "object",
+						"additionalProperties": true,
+					},
+					"max_output_length": map[string]interface{}{
+						"type": "integer",
+					},
+					"action": map[string]interface{}{
+						"type": "object",
+						"properties": map[string]interface{}{
+							"command": map[string]interface{}{
+								"type": "string",
+							},
+							"commands": map[string]interface{}{
+								"type":  "array",
+								"items": map[string]interface{}{"type": "string"},
+							},
+							"timeout_ms": map[string]interface{}{
+								"type": "integer",
+							},
+							"working_directory": map[string]interface{}{
+								"type": "string",
+							},
+							"env": map[string]interface{}{
+								"type":                 "object",
+								"additionalProperties": true,
+							},
+							"max_output_length": map[string]interface{}{
+								"type": "integer",
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func convertResponseToolChoice(raw json.RawMessage) (json.RawMessage, error) {
+	trimmed := bytes.TrimSpace(raw)
+	if len(trimmed) == 0 || string(trimmed) == "null" {
+		return nil, nil
+	}
+
+	var choiceString string
+	if err := json.Unmarshal(trimmed, &choiceString); err == nil {
+		switch choiceString {
+		case "auto", "none", "required":
+			return trimmed, nil
+		default:
+			return nil, fmt.Errorf("unsupported tool_choice value %q", choiceString)
+		}
+	}
+
+	var choiceObj map[string]interface{}
+	if err := json.Unmarshal(trimmed, &choiceObj); err != nil {
+		return nil, fmt.Errorf("tool_choice must be a string or object")
+	}
+
+	choiceType := strings.TrimSpace(asString(choiceObj["type"]))
+	switch choiceType {
+	case "function", "custom":
+		name := strings.TrimSpace(asString(choiceObj["name"]))
+		if name == "" {
+			return nil, fmt.Errorf("tool_choice.name is required")
+		}
+		return json.Marshal(models.ToolChoiceObject{
+			Type: "function",
+			Function: &models.ToolChoiceFunction{
+				Name: name,
+			},
+		})
+	case "apply_patch":
+		return json.Marshal(models.ToolChoiceObject{
+			Type: "function",
+			Function: &models.ToolChoiceFunction{
+				Name: "apply_patch",
+			},
+		})
+	case "shell":
+		return json.Marshal(models.ToolChoiceObject{
+			Type: "function",
+			Function: &models.ToolChoiceFunction{
+				Name: "shell",
+			},
+		})
+	case "local_shell":
+		return json.Marshal(models.ToolChoiceObject{
+			Type: "function",
+			Function: &models.ToolChoiceFunction{
+				Name: "local_shell",
+			},
+		})
+	default:
+		return nil, fmt.Errorf("unsupported tool_choice type %q", choiceType)
+	}
+}
+
+func extractContentText(content interface{}) string {
+	switch v := content.(type) {
+	case string:
+		return v
+	case []interface{}:
+		var b strings.Builder
+		for _, part := range v {
+			if partMap, ok := part.(map[string]interface{}); ok {
+				partType := strings.TrimSpace(asString(partMap["type"]))
+				switch partType {
+				case "input_text", "output_text", "text":
+					b.WriteString(asString(partMap["text"]))
+				case "refusal":
+					b.WriteString(asString(partMap["refusal"]))
+				}
+			}
+		}
+		return b.String()
+	case map[string]interface{}:
+		partType := strings.TrimSpace(asString(v["type"]))
+		switch partType {
+		case "input_text", "output_text", "text":
+			return asString(v["text"])
+		case "refusal":
+			return asString(v["refusal"])
+		}
+	}
+
+	if data, err := json.Marshal(content); err == nil {
+		return string(data)
+	}
+	return ""
+}
+
+func normalizeToolOutput(output interface{}) string {
+	switch v := output.(type) {
+	case string:
+		return v
+	case []interface{}:
+		var b strings.Builder
+		for _, part := range v {
+			if partMap, ok := part.(map[string]interface{}); ok {
+				partType := strings.TrimSpace(asString(partMap["type"]))
+				switch partType {
+				case "output_text", "input_text", "text":
+					b.WriteString(asString(partMap["text"]))
+				case "refusal":
+					b.WriteString(asString(partMap["refusal"]))
+				default:
+					if data, err := json.Marshal(partMap); err == nil {
+						b.WriteString(string(data))
+					}
+				}
+			}
+		}
+		if b.Len() > 0 {
+			return b.String()
+		}
+	case map[string]interface{}:
+		if data, err := json.Marshal(v); err == nil {
+			return string(data)
+		}
+	}
+
+	if data, err := json.Marshal(output); err == nil {
+		return string(data)
+	}
+	return ""
+}
+
+func wrapInputAsJSON(input string) string {
+	payload := map[string]interface{}{
+		"input": input,
+	}
+	if data, err := json.Marshal(payload); err == nil {
+		return string(data)
+	}
+	return "{}"
+}
+
+func wrapJSONArg(key string, value interface{}) string {
+	payload := map[string]interface{}{
+		key: value,
+	}
+	if data, err := json.Marshal(payload); err == nil {
+		return string(data)
+	}
+	return "{}"
+}
+
+func stringifyJSON(value interface{}) string {
+	switch v := value.(type) {
+	case string:
+		return v
+	case json.RawMessage:
+		return string(v)
+	default:
+		if data, err := json.Marshal(v); err == nil {
+			return string(data)
+		}
+	}
+	return ""
+}
+
+func asString(value interface{}) string {
+	switch v := value.(type) {
+	case string:
+		return v
+	case json.Number:
+		return v.String()
+	}
+	return ""
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, v := range values {
+		if strings.TrimSpace(v) != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+func mapRole(role string) string {
+	role = strings.ToLower(strings.TrimSpace(role))
+	switch role {
+	case "developer":
+		return "system"
+	default:
+		if role == "" {
+			return "user"
+		}
+		return role
+	}
+}

services/response_output.go

@@ -0,0 +1,270 @@
+package services
+
+import (
+	"github.com/libaxuan/cursor2api-go/models"
+	"github.com/libaxuan/cursor2api-go/utils"
+	"encoding/json"
+	"strings"
+)
+
+// BuildResponseOutputFromMessage converts a chat completion message into response output items.
+func BuildResponseOutputFromMessage(message models.Message, adapter *ResponseToolAdapter) ([]interface{}, string) {
+	output := make([]interface{}, 0, 1+len(message.ToolCalls))
+	var outputText string
+
+	text := message.GetStringContent()
+	if text != "" {
+		msgItem := buildResponseMessageItem(text)
+		output = append(output, msgItem)
+		outputText = text
+	}
+
+	for _, toolCall := range message.ToolCalls {
+		output = append(output, buildResponseToolCallItem(toolCall, adapter))
+	}
+
+	return output, outputText
+}
+
+func buildResponseMessageItem(text string) models.ResponseOutputMessage {
+	return models.ResponseOutputMessage{
+		ID:     utils.GenerateResponseItemID("msg_"),
+		Type:   "message",
+		Status: "completed",
+		Role:   "assistant",
+		Content: []models.ResponseOutputTextContent{
+			{
+				Type:        "output_text",
+				Text:        text,
+				Annotations: []interface{}{},
+			},
+		},
+	}
+}
+
+func buildResponseToolCallItem(toolCall models.ToolCall, adapter *ResponseToolAdapter) interface{} {
+	name := strings.TrimSpace(toolCall.Function.Name)
+	if name == "" {
+		name = "tool"
+	}
+
+	if adapter == nil || adapter.ToolTypesByName == nil {
+		return buildFunctionCallItem(toolCall, name)
+	}
+
+	switch adapterType := adapter.ToolTypesByName[name]; adapterType {
+	case "apply_patch":
+		return buildApplyPatchCallItem(toolCall)
+	case "shell":
+		return buildShellCallItem(toolCall, adapter.ShellEnvironment)
+	case "local_shell":
+		return buildLocalShellCallItem(toolCall)
+	default:
+		return buildFunctionCallItem(toolCall, name)
+	}
+}
+
+func buildFunctionCallItem(toolCall models.ToolCall, name string) models.ResponseFunctionCall {
+	args := strings.TrimSpace(toolCall.Function.Arguments)
+	if args == "" {
+		args = "{}"
+	}
+	callID := toolCall.ID
+	if callID == "" {
+		callID = utils.GenerateResponseItemID("call_")
+	}
+	return models.ResponseFunctionCall{
+		ID:        utils.GenerateResponseItemID("fc_"),
+		Type:      "function_call",
+		Status:    "completed",
+		CallID:    callID,
+		Name:      name,
+		Arguments: args,
+	}
+}
+
+func buildApplyPatchCallItem(toolCall models.ToolCall) models.ResponseApplyPatchCall {
+	op := parseOperation(toolCall.Function.Arguments)
+	callID := toolCall.ID
+	if callID == "" {
+		callID = utils.GenerateResponseItemID("call_")
+	}
+	return models.ResponseApplyPatchCall{
+		ID:        utils.GenerateResponseItemID("apc_"),
+		Type:      "apply_patch_call",
+		Status:    "completed",
+		CallID:    callID,
+		Operation: op,
+	}
+}
+
+func buildShellCallItem(toolCall models.ToolCall, environment interface{}) models.ResponseShellCall {
+	action := parseShellAction(toolCall.Function.Arguments)
+	callID := toolCall.ID
+	if callID == "" {
+		callID = utils.GenerateResponseItemID("call_")
+	}
+	return models.ResponseShellCall{
+		ID:          utils.GenerateResponseItemID("sc_"),
+		Type:        "shell_call",
+		Status:      "completed",
+		CallID:      callID,
+		Action:      action,
+		Environment: environment,
+	}
+}
+
+func buildLocalShellCallItem(toolCall models.ToolCall) models.ResponseLocalShellCall {
+	action := parseLocalShellAction(toolCall.Function.Arguments)
+	callID := toolCall.ID
+	if callID == "" {
+		callID = utils.GenerateResponseItemID("call_")
+	}
+	return models.ResponseLocalShellCall{
+		ID:     utils.GenerateResponseItemID("lsc_"),
+		Type:   "local_shell_call",
+		Status: "completed",
+		CallID: callID,
+		Action: action,
+	}
+}
+
+func parseOperation(arguments string) map[string]interface{} {
+	args := strings.TrimSpace(arguments)
+	if args == "" {
+		return map[string]interface{}{}
+	}
+
+	var payload map[string]interface{}
+	if err := json.Unmarshal([]byte(args), &payload); err == nil {
+		if op, ok := payload["operation"].(map[string]interface{}); ok {
+			return op
+		}
+		if hasKeys(payload, "type", "path") {
+			return payload
+		}
+		return payload
+	}
+
+	return map[string]interface{}{
+		"diff": args,
+	}
+}
+
+func parseShellAction(arguments string) map[string]interface{} {
+	args := strings.TrimSpace(arguments)
+	if args == "" {
+		return map[string]interface{}{"commands": []string{}}
+	}
+
+	var payload map[string]interface{}
+	if err := json.Unmarshal([]byte(args), &payload); err == nil {
+		if action, ok := payload["action"].(map[string]interface{}); ok {
+			return normalizeShellAction(action)
+		}
+		return normalizeShellAction(payload)
+	}
+
+	return map[string]interface{}{
+		"commands": []string{args},
+	}
+}
+
+func parseLocalShellAction(arguments string) map[string]interface{} {
+	args := strings.TrimSpace(arguments)
+	if args == "" {
+		return map[string]interface{}{"command": ""}
+	}
+
+	var payload map[string]interface{}
+	if err := json.Unmarshal([]byte(args), &payload); err == nil {
+		if action, ok := payload["action"].(map[string]interface{}); ok {
+			return normalizeLocalShellAction(action)
+		}
+		return normalizeLocalShellAction(payload)
+	}
+
+	return map[string]interface{}{
+		"command": args,
+	}
+}
+
+func normalizeShellAction(payload map[string]interface{}) map[string]interface{} {
+	action := map[string]interface{}{}
+
+	if cmds, ok := payload["commands"]; ok {
+		action["commands"] = normalizeStringSlice(cmds)
+	} else if cmd, ok := payload["command"]; ok {
+		action["commands"] = normalizeStringSlice(cmd)
+	}
+
+	if timeout, ok := payload["timeout_ms"]; ok {
+		action["timeout_ms"] = timeout
+	}
+	if maxOut, ok := payload["max_output_length"]; ok {
+		action["max_output_length"] = maxOut
+	}
+
+	if _, exists := action["commands"]; !exists {
+		action["commands"] = []string{}
+	}
+
+	return action
+}
+
+func normalizeLocalShellAction(payload map[string]interface{}) map[string]interface{} {
+	action := map[string]interface{}{}
+
+	if cmd, ok := payload["command"]; ok {
+		action["command"] = cmd
+	} else if cmds, ok := payload["commands"]; ok {
+		action["command"] = cmds
+	}
+
+	if timeout, ok := payload["timeout_ms"]; ok {
+		action["timeout_ms"] = timeout
+	}
+	if wd, ok := payload["working_directory"]; ok {
+		action["working_directory"] = wd
+	}
+	if env, ok := payload["env"]; ok {
+		action["env"] = env
+	}
+	if maxOut, ok := payload["max_output_length"]; ok {
+		action["max_output_length"] = maxOut
+	}
+
+	if _, exists := action["command"]; !exists {
+		action["command"] = ""
+	}
+
+	return action
+}
+
+func normalizeStringSlice(value interface{}) []string {
+	switch v := value.(type) {
+	case []interface{}:
+		result := make([]string, 0, len(v))
+		for _, item := range v {
+			if text, ok := item.(string); ok {
+				result = append(result, text)
+			}
+		}
+		return result
+	case []string:
+		return v
+	case string:
+		return []string{v}
+	default:
+		return []string{}
+	}
+}
+
+func hasKeys(payload map[string]interface{}, keys ...string) bool {
+	for _, key := range keys {
+		if _, ok := payload[key]; !ok {
+			return false
+		}
+	}
+	return true
+}

services/response_response.go

@@ -0,0 +1,107 @@
+package services
+
+import (
+	"bytes"
+	"github.com/libaxuan/cursor2api-go/models"
+	"github.com/libaxuan/cursor2api-go/utils"
+	"encoding/json"
+	"time"
+)
+
+// BuildResponseUsage converts chat-completions usage into responses usage.
+func BuildResponseUsage(usage models.Usage) *models.ResponseUsage {
+	if usage.PromptTokens == 0 && usage.CompletionTokens == 0 && usage.TotalTokens == 0 {
+		return nil
+	}
+
+	return &models.ResponseUsage{
+		InputTokens:  usage.PromptTokens,
+		OutputTokens: usage.CompletionTokens,
+		TotalTokens:  usage.TotalTokens,
+		OutputTokensDetails: &models.ResponseOutputTokensDetails{
+			ReasoningTokens: 0,
+		},
+	}
+}
+
+// NewResponseFromRequest builds a Responses API response with shared request metadata.
+func NewResponseFromRequest(req *models.ResponseRequest, id string, createdAt int64, status string, output []interface{}, outputText string, usage *models.ResponseUsage, completedAt *int64) models.Response {
+	if output == nil {
+		output = []interface{}{}
+	}
+
+	resp := models.Response{
+		ID:                 id,
+		Object:             "response",
+		CreatedAt:          createdAt,
+		Status:             status,
+		CompletedAt:        completedAt,
+		Background:         req.Background,
+		Instructions:       decodeRaw(req.Instructions),
+		MaxOutputTokens:    req.MaxOutputTokens,
+		MaxToolCalls:       req.MaxToolCalls,
+		Model:              req.Model,
+		Output:             output,
+		OutputText:         outputText,
+		ParallelToolCalls:  resolveParallelToolCalls(req.ParallelToolCalls),
+		PreviousResponseID: req.PreviousResponseID,
+		Reasoning:          decodeReasoning(req.Reasoning),
+		Store:              req.Store,
+		Temperature:        req.Temperature,
+		Text:               decodeRaw(req.Text),
+		ToolChoice:         decodeRaw(req.ToolChoice),
+		Tools:              req.Tools,
+		TopP:               req.TopP,
+		Truncation:         req.Truncation,
+		Usage:              usage,
+		User:               req.User,
+		Metadata:           req.Metadata,
+	}
+
+	return resp
+}
+
+// BuildCompletedResponse builds a completed response with a generated ID.
+func BuildCompletedResponse(req *models.ResponseRequest, output []interface{}, outputText string, usage *models.ResponseUsage) models.Response {
+	now := time.Now().Unix()
+	complete := now
+	return NewResponseFromRequest(req, utils.GenerateResponseID(), now, "completed", output, outputText, usage, &complete)
+}
+
+func resolveParallelToolCalls(raw *bool) bool {
+	if raw == nil {
+		return false
+	}
+	return *raw
+}
+
+func decodeRaw(raw json.RawMessage) interface{} {
+	trimmed := bytes.TrimSpace(raw)
+	if len(trimmed) == 0 || string(trimmed) == "null" {
+		return nil
+	}
+	var val interface{}
+	if err := json.Unmarshal(trimmed, &val); err != nil {
+		return nil
+	}
+	return val
+}
+
+func decodeReasoning(raw json.RawMessage) *models.ResponseReasoning {
+	trimmed := bytes.TrimSpace(raw)
+	if len(trimmed) == 0 || string(trimmed) == "null" {
+		return nil
+	}
+	var val map[string]interface{}
+	if err := json.Unmarshal(trimmed, &val); err != nil {
+		return nil
+	}
+	reasoning := &models.ResponseReasoning{}
+	if effort, ok := val["effort"].(string); ok {
+		reasoning.Effort = &effort
+	}
+	if summary, ok := val["summary"]; ok {
+		reasoning.Summary = summary
+	}
+	return reasoning
+}

services/response_store.go

@@ -0,0 +1,128 @@
+package services
+
+import (
+	"github.com/libaxuan/cursor2api-go/models"
+	"sync"
+	"time"
+)
+
+const (
+	defaultResponseStoreTTL        = 30 * time.Minute
+	defaultResponseStoreMaxEntries = 1000
+)
+
+type responseStoreEntry struct {
+	messages  []models.Message
+	createdAt time.Time
+}
+
+// ResponseStore keeps recent Responses API conversation state in memory.
+// It is best-effort and resets on process restart.
+type ResponseStore struct {
+	mu         sync.RWMutex
+	ttl        time.Duration
+	maxEntries int
+	entries    map[string]responseStoreEntry
+	order      []string
+}
+
+func NewResponseStore(ttl time.Duration, maxEntries int) *ResponseStore {
+	if ttl <= 0 {
+		ttl = defaultResponseStoreTTL
+	}
+	if maxEntries <= 0 {
+		maxEntries = defaultResponseStoreMaxEntries
+	}
+
+	return &ResponseStore{
+		ttl:        ttl,
+		maxEntries: maxEntries,
+		entries:    make(map[string]responseStoreEntry),
+		order:      make([]string, 0, maxEntries),
+	}
+}
+
+// Get returns stored messages for a response id if present and not expired.
+func (s *ResponseStore) Get(id string) ([]models.Message, bool) {
+	if id == "" {
+		return nil, false
+	}
+
+	now := time.Now()
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.cleanupLocked(now)
+
+	entry, ok := s.entries[id]
+	if !ok {
+		return nil, false
+	}
+
+	return cloneMessages(entry.messages), true
+}
+
+// Put stores messages for a response id, evicting older entries if needed.
+func (s *ResponseStore) Put(id string, messages []models.Message) {
+	if id == "" || len(messages) == 0 {
+		return
+	}
+
+	now := time.Now()
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.cleanupLocked(now)
+
+	if _, exists := s.entries[id]; !exists {
+		s.order = append(s.order, id)
+	}
+	s.entries[id] = responseStoreEntry{
+		messages:  cloneMessages(messages),
+		createdAt: now,
+	}
+
+	for len(s.entries) > s.maxEntries {
+		s.evictOldestLocked()
+	}
+}
+
+func (s *ResponseStore) cleanupLocked(now time.Time) {
+	if s.ttl <= 0 {
+		return
+	}
+
+	for id, entry := range s.entries {
+		if now.Sub(entry.createdAt) > s.ttl {
+			delete(s.entries, id)
+			s.removeFromOrderLocked(id)
+		}
+	}
+}
+
+func (s *ResponseStore) evictOldestLocked() {
+	if len(s.order) == 0 {
+		return
+	}
+	oldest := s.order[0]
+	s.order = s.order[1:]
+	delete(s.entries, oldest)
+}
+
+func (s *ResponseStore) removeFromOrderLocked(id string) {
+	for i, key := range s.order {
+		if key == id {
+			s.order = append(s.order[:i], s.order[i+1:]...)
+			return
+		}
+	}
+}
+
+func cloneMessages(src []models.Message) []models.Message {
+	if len(src) == 0 {
+		return nil
+	}
+	dst := make([]models.Message, len(src))
+	copy(dst, src)
+	return dst
+}

services/response_stream.go

@@ -0,0 +1,258 @@
+package services
+
+import (
+	"github.com/libaxuan/cursor2api-go/models"
+	"github.com/libaxuan/cursor2api-go/utils"
+	"encoding/json"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+type responseMessageState struct {
+	id          string
+	outputIndex int
+	contentIdx  int
+	text        strings.Builder
+}
+
+// StreamResponse streams a Responses API SSE stream from the Cursor generator.
+func StreamResponse(c *gin.Context, chatGenerator <-chan interface{}, req *models.ResponseRequest, adapter *ResponseToolAdapter, responseID string) {
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+	c.Header("Access-Control-Allow-Origin", "*")
+
+	if strings.TrimSpace(responseID) == "" {
+		responseID = utils.GenerateResponseID()
+	}
+	createdAt := time.Now().Unix()
+	sequence := 0
+
+	outputItems := make([]interface{}, 0, 4)
+	outputText := strings.Builder{}
+	nextOutputIndex := 0
+	var usage *models.ResponseUsage
+	var currentMsg *responseMessageState
+
+	sendEvent := func(event string, payload map[string]interface{}) {
+		sequence++
+		payload["type"] = event
+		payload["sequence_number"] = sequence
+		if data, err := json.Marshal(payload); err == nil {
+			if err := utils.WriteSSEEvent(c.Writer, event, string(data)); err != nil {
+				logrus.WithError(err).Warn("failed to write response SSE event")
+			}
+		}
+	}
+
+	base := NewResponseFromRequest(req, responseID, createdAt, "in_progress", []interface{}{}, "", nil, nil)
+	sendEvent("response.created", map[string]interface{}{"response": base})
+	sendEvent("response.in_progress", map[string]interface{}{"response": base})
+
+	openMessage := func() {
+		if currentMsg != nil {
+			return
+		}
+		msgID := utils.GenerateResponseItemID("msg_")
+		idx := nextOutputIndex
+		nextOutputIndex++
+		currentMsg = &responseMessageState{
+			id:          msgID,
+			outputIndex: idx,
+			contentIdx:  0,
+		}
+
+		item := models.ResponseOutputMessage{
+			ID:      msgID,
+			Type:    "message",
+			Status:  "in_progress",
+			Role:    "assistant",
+			Content: []models.ResponseOutputTextContent{},
+		}
+		sendEvent("response.output_item.added", map[string]interface{}{
+			"output_index": idx,
+			"item":         item,
+		})
+
+		part := models.ResponseOutputTextContent{
+			Type:        "output_text",
+			Text:        "",
+			Annotations: []interface{}{},
+		}
+		sendEvent("response.content_part.added", map[string]interface{}{
+			"output_index":  idx,
+			"content_index": currentMsg.contentIdx,
+			"part":          part,
+		})
+	}
+
+	closeMessage := func() {
+		if currentMsg == nil {
+			return
+		}
+		text := currentMsg.text.String()
+		part := models.ResponseOutputTextContent{
+			Type:        "output_text",
+			Text:        text,
+			Annotations: []interface{}{},
+		}
+
+		sendEvent("response.output_text.done", map[string]interface{}{
+			"output_index":  currentMsg.outputIndex,
+			"content_index": currentMsg.contentIdx,
+			"text":          text,
+		})
+		sendEvent("response.content_part.done", map[string]interface{}{
+			"output_index":  currentMsg.outputIndex,
+			"content_index": currentMsg.contentIdx,
+			"part":          part,
+		})
+
+		item := models.ResponseOutputMessage{
+			ID:      currentMsg.id,
+			Type:    "message",
+			Status:  "completed",
+			Role:    "assistant",
+			Content: []models.ResponseOutputTextContent{part},
+		}
+
+		sendEvent("response.output_item.done", map[string]interface{}{
+			"output_index": currentMsg.outputIndex,
+			"item":         item,
+		})
+
+		outputItems = append(outputItems, item)
+		currentMsg = nil
+	}
+
+	emitToolCall := func(toolCall models.ToolCall) {
+		closeMessage()
+		item := buildResponseToolCallItem(toolCall, adapter)
+		idx := nextOutputIndex
+		nextOutputIndex++
+
+		added := withOutputItemStatus(item, "in_progress")
+		sendEvent("response.output_item.added", map[string]interface{}{
+			"output_index": idx,
+			"item":         added,
+		})
+
+		if callInfo, ok := getFunctionCallInfo(item); ok {
+			sendEvent("response.function_call_arguments.delta", map[string]interface{}{
+				"output_index": idx,
+				"item_id":      callInfo.ID,
+				"delta":        callInfo.Arguments,
+			})
+			sendEvent("response.function_call_arguments.done", map[string]interface{}{
+				"output_index": idx,
+				"item_id":      callInfo.ID,
+				"arguments":    callInfo.Arguments,
+				"name":         callInfo.Name,
+			})
+		}
+
+		done := withOutputItemStatus(item, "completed")
+		sendEvent("response.output_item.done", map[string]interface{}{
+			"output_index": idx,
+			"item":         done,
+		})
+
+		outputItems = append(outputItems, done)
+	}
+
+	ctx := c.Request.Context()
+	for {
+		select {
+		case <-ctx.Done():
+			logrus.Debug("client disconnected during responses streaming")
+			return
+		case data, ok := <-chatGenerator:
+			if !ok {
+				closeMessage()
+				completedAt := time.Now().Unix()
+				final := NewResponseFromRequest(req, responseID, createdAt, "completed", outputItems, outputText.String(), usage, &completedAt)
+				sendEvent("response.completed", map[string]interface{}{"response": final})
+				return
+			}
+
+			switch v := data.(type) {
+			case models.AssistantEvent:
+				switch v.Kind {
+				case models.AssistantEventText:
+					if v.Text != "" {
+						openMessage()
+						currentMsg.text.WriteString(v.Text)
+						outputText.WriteString(v.Text)
+						sendEvent("response.output_text.delta", map[string]interface{}{
+							"output_index":  currentMsg.outputIndex,
+							"content_index": currentMsg.contentIdx,
+							"delta":         v.Text,
+						})
+					}
+				case models.AssistantEventToolCall:
+					if v.ToolCall != nil {
+						emitToolCall(*v.ToolCall)
+					}
+				}
+			case string:
+				if v != "" {
+					openMessage()
+					currentMsg.text.WriteString(v)
+					outputText.WriteString(v)
+					sendEvent("response.output_text.delta", map[string]interface{}{
+						"output_index":  currentMsg.outputIndex,
+						"content_index": currentMsg.contentIdx,
+						"delta":         v,
+					})
+				}
+			case models.Usage:
+				usage = BuildResponseUsage(v)
+			case error:
+				logrus.WithError(v).Error("responses stream generator error")
+				return
+			default:
+				continue
+			}
+		}
+	}
+}
+
+type functionCallInfo struct {
+	ID        string
+	Name      string
+	Arguments string
+}
+
+func getFunctionCallInfo(item interface{}) (*functionCallInfo, bool) {
+	switch v := item.(type) {
+	case models.ResponseFunctionCall:
+		return &functionCallInfo{ID: v.ID, Name: v.Name, Arguments: v.Arguments}, true
+	default:
+		return nil, false
+	}
+}
+
+func withOutputItemStatus(item interface{}, status string) interface{} {
+	switch v := item.(type) {
+	case models.ResponseOutputMessage:
+		v.Status = status
+		return v
+	case models.ResponseFunctionCall:
+		v.Status = status
+		return v
+	case models.ResponseApplyPatchCall:
+		v.Status = status
+		return v
+	case models.ResponseShellCall:
+		v.Status = status
+		return v
+	case models.ResponseLocalShellCall:
+		v.Status = status
+		return v
+	default:
+		return item
+	}
+}

start-go-utf8.bat

@@ -0,0 +1,128 @@
+@echo off
+chcp 65001 >nul 2>&1
+setlocal enabledelayedexpansion
+
+::  Cursor2API启动脚本
+
+echo.
+echo =========================================
+echo     🚀  Cursor2API启动器
+echo =========================================
+echo.
+
+:: 检查Go是否安装
+go version >nul 2>&1
+if errorlevel 1 (
+    echo ❌ Go 未安装，请先安装 Go 1.21 或更高版本
+    echo 💡 安装方法: https://golang.org/dl/
+    pause
+    exit /b 1
+)
+
+:: 显示Go版本并检查版本号
+for /f "tokens=3" %%i in ('go version') do set GO_VERSION=%%i
+set GO_VERSION=!GO_VERSION:go=!
+
+:: 检查Go版本是否满足要求 (需要 >= 1.21)
+for /f "tokens=1,2 delims=." %%a in ("!GO_VERSION!") do (
+    set MAJOR=%%a
+    set MINOR=%%b
+)
+if !MAJOR! LSS 1 (
+    echo ❌ Go 版本 !GO_VERSION! 过低，请安装 Go 1.21 或更高版本
+    pause
+    exit /b 1
+)
+if !MAJOR! EQU 1 if !MINOR! LSS 21 (
+    echo ❌ Go 版本 !GO_VERSION! 过低，请安装 Go 1.21 或更高版本
+    pause
+    exit /b 1
+)
+
+echo ✅ Go 版本检查通过: !GO_VERSION!
+
+:: 检查Node.js是否安装
+node --version >nul 2>&1
+if errorlevel 1 (
+    echo ❌ Node.js 未安装，请先安装 Node.js 18 或更高版本
+    echo 💡 安装方法: https://nodejs.org/
+    pause
+    exit /b 1
+)
+
+:: 显示Node.js版本并检查版本号
+for /f "delims=" %%i in ('node --version') do set NODE_VERSION=%%i
+set NODE_VERSION=!NODE_VERSION:v=!
+
+:: 检查Node.js版本是否满足要求 (需要 >= 18)
+for /f "tokens=1 delims=." %%a in ("!NODE_VERSION!") do set NODE_MAJOR=%%a
+if !NODE_MAJOR! LSS 18 (
+    echo ❌ Node.js 版本 !NODE_VERSION! 过低，请安装 Node.js 18 或更高版本
+    pause
+    exit /b 1
+)
+
+echo ✅ Node.js 版本检查通过: !NODE_VERSION!
+
+:: 创建.env文件（如果不存在）
+if not exist .env (
+    echo 📝 创建默认 .env 配置文件...
+    (
+        echo # 服务器配置
+        echo PORT=8002
+        echo DEBUG=false
+        echo.
+        echo # API配置
+        echo API_KEY=0000
+        echo MODELS=claude-sonnet-4.6
+        echo SYSTEM_PROMPT_INJECT=
+        echo.
+        echo # 请求配置
+        echo TIMEOUT=30
+        echo USER_AGENT=Mozilla/5.0 ^(Windows NT 10.0; Win64; x64^) AppleWebKit/537.36 ^(KHTML, like Gecko^) Chrome/140.0.0.0 Safari/537.36
+        echo.
+        echo # Cursor配置
+        echo SCRIPT_URL=https://cursor.com/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/a-4-a/c.js?i=0^^^&v=3^^^&h=cursor.com
+    ) > .env
+    echo ✅ 默认 .env 文件已创建
+) else (
+    echo ✅ 配置文件 .env 已存在
+)
+
+:: 下载依赖
+echo.
+echo 📦 正在下载 Go 依赖...
+go mod download
+if errorlevel 1 (
+    echo ❌ 依赖下载失败！
+    pause
+    exit /b 1
+)
+
+:: 构建应用
+echo 🔨 正在编译 Go 应用...
+go build -o cursor2api-go.exe .
+if errorlevel 1 (
+    echo ❌ 编译失败！
+    pause
+    exit /b 1
+)
+
+:: 检查构建是否成功
+if not exist cursor2api-go.exe (
+    echo ❌ 编译失败 - 可执行文件未找到！
+    pause
+    exit /b 1
+)
+
+echo ✅ 应用编译成功！
+
+:: 显示服务信息
+echo.
+echo ✅ 准备就绪，正在启动服务...
+echo.
+
+:: 启动服务
+cursor2api-go.exe
+
+pause

start-go.bat

@@ -0,0 +1,128 @@
+@echo off
+chcp 65001 >nul 2>&1
+setlocal enabledelayedexpansion
+
+:: Cursor2API Go启动脚本
+
+echo.
+echo =========================================
+echo     🚀  Cursor2API启动器 Go版本
+echo =========================================
+echo.
+
+:: 检查Go是否安装
+go version >nul 2>&1
+if errorlevel 1 (
+    echo [错误] Go 未安装，请先安装 Go 1.21 或更高版本
+    echo [提示] 安装方法: https://golang.org/dl/
+    pause
+    exit /b 1
+)
+
+:: 显示Go版本并检查版本号
+for /f "tokens=3" %%i in ('go version') do set GO_VERSION=%%i
+set GO_VERSION=!GO_VERSION:go=!
+
+:: 检查Go版本是否满足要求 (需要 >= 1.21)
+for /f "tokens=1,2 delims=." %%a in ("!GO_VERSION!") do (
+    set MAJOR=%%a
+    set MINOR=%%b
+)
+if !MAJOR! LSS 1 (
+    echo [错误] Go 版本 !GO_VERSION! 过低，请安装 Go 1.21 或更高版本
+    pause
+    exit /b 1
+)
+if !MAJOR! EQU 1 if !MINOR! LSS 21 (
+    echo [错误] Go 版本 !GO_VERSION! 过低，请安装 Go 1.21 或更高版本
+    pause
+    exit /b 1
+)
+
+echo [成功] Go 版本检查通过: !GO_VERSION!
+
+:: 检查Node.js是否安装
+node --version >nul 2>&1
+if errorlevel 1 (
+    echo [错误] Node.js 未安装，请先安装 Node.js 18 或更高版本
+    echo [提示] 安装方法: https://nodejs.org/
+    pause
+    exit /b 1
+)
+
+:: 显示Node.js版本并检查版本号
+for /f "delims=" %%i in ('node --version') do set NODE_VERSION=%%i
+set NODE_VERSION=!NODE_VERSION:v=!
+
+:: 检查Node.js版本是否满足要求 (需要 >= 18)
+for /f "tokens=1 delims=." %%a in ("!NODE_VERSION!") do set NODE_MAJOR=%%a
+if !NODE_MAJOR! LSS 18 (
+    echo [错误] Node.js 版本 !NODE_VERSION! 过低，请安装 Node.js 18 或更高版本
+    pause
+    exit /b 1
+)
+
+echo [成功] Node.js 版本检查通过: !NODE_VERSION!
+
+:: 创建.env文件（如果不存在）
+if not exist .env (
+    echo [信息] 创建默认 .env 配置文件...
+    (
+        echo # 服务器配置
+        echo PORT=8002
+        echo DEBUG=false
+        echo.
+        echo # API配置
+        echo API_KEY=0000
+        echo MODELS=claude-sonnet-4.6
+        echo SYSTEM_PROMPT_INJECT=
+        echo.
+        echo # 请求配置
+        echo TIMEOUT=30
+        echo USER_AGENT=Mozilla/5.0 ^(Windows NT 10.0; Win64; x64^) AppleWebKit/537.36 ^(KHTML, like Gecko^) Chrome/140.0.0.0 Safari/537.36
+        echo.
+        echo # Cursor配置
+        echo SCRIPT_URL=https://cursor.com/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/a-4-a/c.js?i=0^^^&v=3^^^&h=cursor.com
+    ) > .env
+    echo [成功] 默认 .env 文件已创建
+) else (
+    echo [成功] 配置文件 .env 已存在
+)
+
+:: 下载依赖
+echo.
+echo [信息] 正在下载 Go 依赖...
+go mod download
+if errorlevel 1 (
+    echo [错误] 依赖下载失败！
+    pause
+    exit /b 1
+)
+
+:: 构建应用
+echo [信息] 正在编译 Go 应用...
+go build -o cursor2api-go.exe .
+if errorlevel 1 (
+    echo [错误] 编译失败！
+    pause
+    exit /b 1
+)
+
+:: 检查构建是否成功
+if not exist cursor2api-go.exe (
+    echo [错误] 编译失败 - 可执行文件未找到
+    pause
+    exit /b 1
+)
+
+echo [成功] 应用编译成功！
+
+:: 显示服务信息
+echo.
+echo [成功] 准备就绪，正在启动服务...
+echo.
+
+:: 启动服务
+cursor2api-go.exe
+
+pause

start.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+
+#  Cursor2API启动脚本
+
+set -e
+
+# 定义颜色代码
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+PURPLE='\033[0;35m'
+CYAN='\033[0;36m'
+WHITE='\033[1;37m'
+NC='\033[0m' # No Color
+
+# 打印标题
+print_header() {
+    echo ""
+    echo -e "${CYAN}=========================================${NC}"
+    echo -e "${WHITE}    🚀  Cursor2API启动器${NC}"
+    echo -e "${CYAN}=========================================${NC}"
+}
+
+# 检查Go环境
+check_go() {
+    if ! command -v go &> /dev/null; then
+        echo -e "${RED}❌ Go 未安装，请先安装 Go 1.21 或更高版本${NC}"
+        echo -e "${YELLOW}💡 安装方法: https://golang.org/dl/${NC}"
+        exit 1
+    fi
+
+    GO_VERSION=$(go version | awk '{print $3}' | sed 's/go//')
+    REQUIRED_VERSION="1.21"
+
+    if [ "$(printf '%s\n' "$REQUIRED_VERSION" "$GO_VERSION" | sort -V | head -n1)" != "$REQUIRED_VERSION" ]; then
+        echo -e "${RED}❌ Go 版本 $GO_VERSION 过低，请安装 Go $REQUIRED_VERSION 或更高版本${NC}"
+        exit 1
+    fi
+
+    echo -e "${GREEN}✅ Go 版本检查通过: $GO_VERSION${NC}"
+}
+
+# 检查Node.js环境
+check_nodejs() {
+    if ! command -v node &> /dev/null; then
+        echo -e "${RED}❌ Node.js 未安装，请先安装 Node.js 18 或更高版本${NC}"
+        echo -e "${YELLOW}💡 安装方法: https://nodejs.org/${NC}"
+        exit 1
+    fi
+
+    NODE_VERSION=$(node --version | sed 's/v//')
+    REQUIRED_VERSION="18.0.0"
+
+    if [ "$(printf '%s\n' "$REQUIRED_VERSION" "$NODE_VERSION" | sort -V | head -n1)" != "$REQUIRED_VERSION" ]; then
+        echo -e "${RED}❌ Node.js 版本 $NODE_VERSION 过低，请安装 Node.js $REQUIRED_VERSION 或更高版本${NC}"
+        exit 1
+    fi
+
+    echo -e "${GREEN}✅ Node.js 版本检查通过: $NODE_VERSION${NC}"
+}
+
+# 处理环境配置
+setup_env() {
+    if [ ! -f .env ]; then
+        echo -e "${YELLOW}📝 创建默认 .env 配置文件...${NC}"
+        cat > .env << EOF
+# 服务器配置
+PORT=8002
+DEBUG=false
+
+# API配置
+API_KEY=0000
+MODELS=claude-sonnet-4.6
+SYSTEM_PROMPT_INJECT=
+
+# 请求配置
+TIMEOUT=30
+USER_AGENT=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36
+
+# Cursor配置
+SCRIPT_URL=https://cursor.com/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/a-4-a/c.js?i=0&v=3&h=cursor.com
+EOF
+        echo -e "${GREEN}✅ 默认 .env 文件已创建${NC}"
+    else
+        echo -e "${GREEN}✅ 配置文件 .env 已存在${NC}"
+    fi
+}
+
+# 构建应用
+build_app() {
+    echo -e "${BLUE}📦 正在下载 Go 依赖...${NC}"
+    go mod download
+
+    echo -e "${BLUE}🔨 正在编译 Go 应用...${NC}"
+    go build -o cursor2api-go .
+
+    if [ ! -f cursor2api-go ]; then
+        echo -e "${RED}❌ 编译失败！${NC}"
+        exit 1
+    fi
+
+    echo -e "${GREEN}✅ 应用编译成功！${NC}"
+}
+
+# 显示服务信息
+show_info() {
+    echo ""
+    echo -e "${GREEN}✅ 准备就绪，正在启动服务...${NC}"
+    echo ""
+}
+
+# 启动服务器
+start_server() {
+    # 捕获中断信号
+    trap 'echo -e "\n${YELLOW}⏹️  正在停止服务器...${NC}"; exit 0' INT
+
+    ./cursor2api-go
+}
+
+# 主函数
+main() {
+    print_header
+    check_go
+    check_nodejs
+    setup_env
+    build_app
+    show_info
+    start_server
+}
+
+# 运行主函数
+main

static/docs.html

@@ -0,0 +1,550 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cursor2API - 强大的AI模型API代理</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            line-height: 1.6;
+            color: #333;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+
+        .header {
+            text-align: center;
+            color: white;
+            margin-bottom: 40px;
+        }
+
+        .header h1 {
+            font-size: 3rem;
+            font-weight: 700;
+            margin-bottom: 10px;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+        }
+
+        .header .subtitle {
+            font-size: 1.2rem;
+            opacity: 0.9;
+        }
+
+        .main-content {
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
+            overflow: hidden;
+        }
+
+        .nav-tabs {
+            display: flex;
+            background: #f8f9fa;
+            border-bottom: 1px solid #e9ecef;
+        }
+
+        .nav-tab {
+            flex: 1;
+            padding: 20px;
+            text-align: center;
+            cursor: pointer;
+            font-weight: 600;
+            color: #6c757d;
+            transition: all 0.3s ease;
+            border: none;
+            background: none;
+        }
+
+        .nav-tab:hover {
+            background: #e9ecef;
+            color: #495057;
+        }
+
+        .nav-tab.active {
+            background: #007bff;
+            color: white;
+        }
+
+        .tab-content {
+            display: none;
+            padding: 40px;
+        }
+
+        .tab-content.active {
+            display: block;
+        }
+
+        .status-card {
+            background: linear-gradient(135deg, #28a745, #20c997);
+            color: white;
+            padding: 30px;
+            border-radius: 15px;
+            margin-bottom: 30px;
+            text-align: center;
+        }
+
+        .api-info {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+
+        .info-card {
+            background: #f8f9fa;
+            padding: 25px;
+            border-radius: 15px;
+            border-left: 4px solid #007bff;
+        }
+
+        .info-card h3 {
+            color: #007bff;
+            margin-bottom: 15px;
+        }
+
+        .info-card .value {
+            font-family: Monaco, monospace;
+            background: white;
+            padding: 10px;
+            border-radius: 8px;
+            font-weight: bold;
+        }
+
+        .models-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+
+        .model-card {
+            background: white;
+            border: 2px solid #e9ecef;
+            border-radius: 15px;
+            padding: 20px;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            text-align: center;
+        }
+
+        .model-card:hover {
+            border-color: #007bff;
+            transform: translateY(-5px);
+            box-shadow: 0 10px 25px rgba(0, 123, 255, 0.2);
+        }
+
+        .model-card.selected {
+            border-color: #007bff;
+            background: #f8f9ff;
+        }
+
+        .model-card .model-name {
+            font-size: 1.2rem;
+            font-weight: bold;
+            color: #007bff;
+            margin-bottom: 8px;
+        }
+
+        .model-card .provider {
+            font-size: 0.9rem;
+            color: #6c757d;
+            opacity: 0.8;
+        }
+
+        .code-block {
+            background: #f8f9fa;
+            border: 1px solid #e9ecef;
+            border-radius: 10px;
+            padding: 20px;
+            margin: 20px 0;
+            position: relative;
+        }
+
+        .copy-btn {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            background: #007bff;
+            color: white;
+            border: none;
+            padding: 8px 15px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 0.9rem;
+            transition: background 0.3s ease;
+        }
+
+        .copy-btn:hover {
+            background: #0056b3;
+        }
+
+        .code-block code {
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            font-size: 0.9rem;
+            line-height: 1.5;
+            display: block;
+            white-space: pre-wrap;
+            word-break: break-all;
+        }
+
+        .endpoint-card {
+            background: #f8f9fa;
+            border-radius: 10px;
+            padding: 20px;
+            margin: 15px 0;
+            border-left: 4px solid #007bff;
+        }
+
+        .method-badge {
+            display: inline-block;
+            padding: 4px 12px;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            font-weight: bold;
+            margin-right: 10px;
+        }
+
+        .method-get {
+            background: #28a745;
+            color: white;
+        }
+
+        .method-post {
+            background: #007bff;
+            color: white;
+        }
+
+        .footer {
+            text-align: center;
+            padding: 30px;
+            color: #6c757d;
+            background: rgba(255, 255, 255, 0.9);
+            margin-top: 40px;
+            border-radius: 15px;
+        }
+
+        @media (max-width: 768px) {
+            .header h1 {
+                font-size: 2rem;
+            }
+
+            .models-grid {
+                grid-template-columns: 1fr;
+            }
+
+            .api-info {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🚀 Cursor2API</h1>
+            <p class="subtitle">强大的AI模型API代理服务 - OpenAI兼容接口</p>
+        </div>
+
+        <div class="main-content">
+            <!-- 导航标签 -->
+            <div class="nav-tabs">
+                <button class="nav-tab active" onclick="showTab('overview')">概览</button>
+                <button class="nav-tab" onclick="showTab('models')">模型列表</button>
+                <button class="nav-tab" onclick="showTab('api')">API文档</button>
+            </div>
+
+            <!-- 概览页面 -->
+            <div id="overview" class="tab-content active">
+                <div class="status-card">
+                    <h2>✅ 服务运行正常</h2>
+                    <p> Cursor2API已成功启动并运行中</p>
+                </div>
+
+                <div class="api-info">
+                    <div class="info-card">
+                        <h3>📍 服务地址</h3>
+                        <div class="value">http://localhost:8002</div>
+                    </div>
+                    <div class="info-card">
+                        <h3>🔑 API密钥</h3>
+                        <div class="value">0000 (默认)</div>
+                    </div>
+                    <div class="info-card">
+                        <h3>🎯 兼容性</h3>
+                        <div class="value">OpenAI API 标准</div>
+                    </div>
+                    <div class="info-card">
+                        <h3>🌊 流式支持</h3>
+                        <div class="value">支持 SSE 流式响应</div>
+                    </div>
+                    <div class="info-card">
+                        <h3>🧰 Tool Calls</h3>
+                        <div class="value">支持 tools / tool_choice / tool_calls</div>
+                    </div>
+                    <div class="info-card">
+                        <h3>🧠 Thinking</h3>
+                        <div class="value">自动暴露 -thinking 模型（thinking 不对外透出）</div>
+                    </div>
+                </div>
+
+                <div style="margin-top: 30px;">
+                    <h3>🚀 快速开始</h3>
+
+                    <div class="code-block">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code># 获取模型列表
+curl -H "Authorization: Bearer 0000" http://localhost:8002/v1/models</code>
+                    </div>
+
+                    <h4 style="margin-top: 15px; color: #555;">非流式聊天 (Non-Streaming)</h4>
+                    <div class="code-block">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code>curl -X POST http://localhost:8002/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer 0000" \
+  -d '{
+    "model": "claude-sonnet-4.6",
+    "messages": [{"role": "user", "content": "Hello!"}],
+    "stream": false
+  }'</code>
+                    </div>
+
+                    <h4 style="margin-top: 15px; color: #555;">流式聊天 (Streaming)</h4>
+                    <div class="code-block">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code>curl -X POST http://localhost:8002/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer 0000" \
+  -d '{
+    "model": "claude-sonnet-4.6",
+    "messages": [{"role": "user", "content": "Hello!"}],
+    "stream": true
+  }'</code>
+                    </div>
+
+                    <h4 style="margin-top: 15px; color: #555;">工具调用 (Tool Calls)</h4>
+                    <div class="code-block">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code>curl -X POST http://localhost:8002/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer 0000" \
+  -d '{
+    "model": "claude-sonnet-4.6",
+    "messages": [{"role": "user", "content": "What is 2+2? Use the calculator tool."}],
+    "tools": [
+      {
+        "type": "function",
+        "function": {
+          "name": "calculator",
+          "description": "Evaluate a simple arithmetic expression.",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "expression": {"type": "string"}
+            },
+            "required": ["expression"]
+          }
+        }
+      }
+    ],
+    "tool_choice": {"type": "function", "function": {"name": "calculator"}},
+    "stream": false
+  }'</code>
+                    </div>
+
+                    <h4 style="margin-top: 15px; color: #555;">Kilo Code 兼容（可选）</h4>
+                    <div class="code-block">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code># 当上层强制“必须用工具”时，可在 .env 开启
+KILO_TOOL_STRICT=true
+
+# 非流式请求：若要求用工具但本轮未产出 tool_calls，会自动重试 1 次（流式不重试）</code>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 模型页面 -->
+            <div id="models" class="tab-content">
+                <h2>🤖 支持的AI模型</h2>
+                <p>点击模型卡片可查看详细信息和使用示例</p>
+
+                <div class="models-grid" id="modelsGrid">
+                    <div class="model-card" onclick="selectModel('claude-sonnet-4.6')">
+                        <div class="model-name">claude-sonnet-4.6</div>
+                        <div class="provider">Anthropic Claude</div>
+                    </div>
+                    <div class="model-card" onclick="selectModel('claude-sonnet-4.6-thinking')">
+                        <div class="model-name">claude-sonnet-4.6-thinking</div>
+                        <div class="provider">Anthropic Claude + Thinking</div>
+                    </div>
+                </div>
+
+                <div id="selectedModelInfo" style="display: none; margin-top: 30px;">
+                    <h3>使用选中的模型</h3>
+                    <div class="code-block">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code id="modelExample"></code>
+                    </div>
+                </div>
+            </div>
+
+            <!-- API页面 -->
+            <div id="api" class="tab-content">
+                <h2>📡 API端点文档</h2>
+
+                <div class="endpoint-card">
+                    <div class="method-badge method-get">GET</div>
+                    <strong>/v1/models</strong>
+                    <p>获取所有可用的AI模型列表</p>
+                    <div class="code-block" style="margin-top: 15px;">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code>curl -H "Authorization: Bearer 0000" http://localhost:8002/v1/models</code>
+                    </div>
+                </div>
+
+                <div class="endpoint-card">
+                    <div class="method-badge method-post">POST</div>
+                    <strong>/v1/chat/completions</strong>
+                    <p>创建聊天完成请求，支持流式、非流式和 OpenAI 兼容 tool_calls</p>
+                    <div class="code-block" style="margin-top: 15px;">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code>curl -X POST http://localhost:8002/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer 0000" \
+  -d '{
+    "model": "claude-sonnet-4.6",
+    "messages": [
+      {"role": "user", "content": "你好"}
+    ],
+    "stream": false
+  }'</code>
+                    </div>
+                    <p style="margin-top: 10px; color: #555;">
+                        说明：当响应包含工具调用时，非流式会返回 <code>message.tool_calls</code> 且 <code>finish_reason="tool_calls"</code>；
+                        流式会在 <code>delta.tool_calls</code> 中输出，并在最后一个 chunk 以 <code>finish_reason="tool_calls"</code> 收尾。
+                    </p>
+                </div>
+
+                <div class="endpoint-card">
+                    <div class="method-badge method-post">POST</div>
+                    <strong>/v1/responses</strong>
+                    <p>Responses API 兼容端点，支持输入项、工具调用与流式输出</p>
+                    <div class="code-block" style="margin-top: 15px;">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code>curl -X POST http://localhost:8002/v1/responses \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer 0000" \
+  -d '{
+    "model": "claude-sonnet-4.6",
+    "input": "你好",
+    "stream": false
+  }'</code>
+                    </div>
+                    <p style="margin-top: 10px; color: #555;">
+                        说明：当响应包含工具调用时，会返回 <code>output</code> 数组中的 <code>function_call</code>、
+                        <code>apply_patch_call</code>、<code>shell_call</code> 或 <code>local_shell_call</code> 等输出项。
+                    </p>
+                </div>
+
+                <div class="endpoint-card">
+                    <div class="method-badge method-get">GET</div>
+                    <strong>/health</strong>
+                    <p>健康检查端点</p>
+                    <div class="code-block" style="margin-top: 15px;">
+                        <button class="copy-btn" onclick="copyCode(this)">复制</button>
+                        <code>curl http://localhost:8002/health</code>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div class="footer">
+            <p>©2025 Cursor2API | 强大的AI模型API代理服务</p>
+        </div>
+    </div>
+
+    <script>
+        // 切换标签页
+        function showTab(tabName) {
+            const tabContents = document.getElementsByClassName('tab-content');
+            for (let i = 0; i < tabContents.length; i++) {
+                tabContents[i].classList.remove('active');
+            }
+
+            const tabBtns = document.getElementsByClassName('nav-tab');
+            for (let i = 0; i < tabBtns.length; i++) {
+                tabBtns[i].classList.remove('active');
+            }
+
+            document.getElementById(tabName).classList.add('active');
+            event.target.classList.add('active');
+        }
+
+        // 选择模型
+        function selectModel(modelId) {
+            const prevSelected = document.querySelector('.model-card.selected');
+            if (prevSelected) {
+                prevSelected.classList.remove('selected');
+            }
+
+            const modelCards = document.querySelectorAll('.model-card');
+            modelCards.forEach(card => {
+                if (card.onclick.toString().includes(modelId)) {
+                    card.classList.add('selected');
+                }
+            });
+
+            const exampleCode = `curl -X POST http://localhost:8002/v1/chat/completions \\
+  -H "Content-Type: application/json" \\
+  -H "Authorization: Bearer 0000" \\
+  -d '{
+    "model": "${modelId}",
+    "messages": [
+      {
+        "role": "user",
+        "content": "你好，请用中文回答问题"
+      }
+    ],
+    "stream": false
+  }'`;
+
+            document.getElementById('modelExample').textContent = exampleCode;
+            document.getElementById('selectedModelInfo').style.display = 'block';
+        }
+
+        // 复制代码功能
+        function copyCode(btn) {
+            const codeBlock = btn.nextElementSibling;
+            const code = codeBlock.textContent;
+
+            navigator.clipboard.writeText(code).then(() => {
+                const originalText = btn.textContent;
+                btn.textContent = '已复制!';
+                btn.style.background = '#28a745';
+                setTimeout(() => {
+                    btn.textContent = originalText;
+                    btn.style.background = '#007bff';
+                }, 2000);
+            }).catch(() => {
+                alert('复制失败，请手动复制代码');
+            });
+        }
+    </script>
+</body>
+
+</html>

utils/cursor_protocol.go

@@ -0,0 +1,279 @@
+package utils
+
+import (
+	"bytes"
+	"github.com/libaxuan/cursor2api-go/models"
+	"encoding/json"
+	"strings"
+)
+
+const (
+	thinkingStartTag = "<thinking>"
+	thinkingEndTag   = "</thinking>"
+	invokeEndTag     = "</invoke>"
+)
+
+// CursorProtocolParser 将 Cursor 的纯文本增量转换为内部文本/thinking/tool_call 事件
+type CursorProtocolParser struct {
+	config  models.CursorParseConfig
+	pending string
+}
+
+// NewCursorProtocolParser 创建新的协议解析器
+func NewCursorProtocolParser(config models.CursorParseConfig) *CursorProtocolParser {
+	return &CursorProtocolParser{config: config}
+}
+
+// Feed 喂入一个上游增量片段
+func (p *CursorProtocolParser) Feed(chunk string) []models.AssistantEvent {
+	if chunk == "" {
+		return nil
+	}
+	p.pending += chunk
+	return p.extract(false)
+}
+
+// Finish 在流结束时刷新剩余缓冲
+func (p *CursorProtocolParser) Finish() []models.AssistantEvent {
+	events := p.extract(true)
+	if p.pending != "" {
+		events = append(events, models.AssistantEvent{
+			Kind: models.AssistantEventText,
+			Text: p.pending,
+		})
+		p.pending = ""
+	}
+	return events
+}
+
+func (p *CursorProtocolParser) extract(final bool) []models.AssistantEvent {
+	events := make([]models.AssistantEvent, 0, 4)
+
+	for len(p.pending) > 0 {
+		idx, kind := p.findNextSpecial()
+		if idx < 0 {
+			keep := 0
+			if !final {
+				keep = p.partialStartKeep()
+			}
+			if len(p.pending) <= keep {
+				break
+			}
+			text := p.pending[:len(p.pending)-keep]
+			p.pending = p.pending[len(p.pending)-keep:]
+			if text != "" {
+				events = append(events, models.AssistantEvent{
+					Kind: models.AssistantEventText,
+					Text: text,
+				})
+			}
+			continue
+		}
+
+		if idx > 0 {
+			text := p.pending[:idx]
+			p.pending = p.pending[idx:]
+			if text != "" {
+				events = append(events, models.AssistantEvent{
+					Kind: models.AssistantEventText,
+					Text: text,
+				})
+			}
+			continue
+		}
+
+		switch kind {
+		case models.AssistantEventThinking:
+			if event, ok := p.tryParseThinking(final); ok {
+				events = append(events, event)
+				continue
+			}
+			if !final {
+				return events
+			}
+		case models.AssistantEventToolCall:
+			if event, ok := p.tryParseToolCall(final); ok {
+				events = append(events, event)
+				continue
+			}
+			if !final {
+				return events
+			}
+		}
+
+		events = append(events, models.AssistantEvent{
+			Kind: models.AssistantEventText,
+			Text: p.pending,
+		})
+		p.pending = ""
+	}
+
+	return events
+}
+
+func (p *CursorProtocolParser) findNextSpecial() (int, models.AssistantEventKind) {
+	bestIdx := -1
+	bestKind := models.AssistantEventText
+
+	if p.config.ThinkingEnabled {
+		if idx := strings.Index(p.pending, thinkingStartTag); idx >= 0 {
+			bestIdx = idx
+			bestKind = models.AssistantEventThinking
+		}
+	}
+
+	if p.config.TriggerSignal != "" {
+		if idx := strings.Index(p.pending, p.config.TriggerSignal); idx >= 0 && (bestIdx < 0 || idx < bestIdx) {
+			bestIdx = idx
+			bestKind = models.AssistantEventToolCall
+		}
+	}
+
+	return bestIdx, bestKind
+}
+
+func (p *CursorProtocolParser) partialStartKeep() int {
+	maxKeep := 0
+	if p.config.ThinkingEnabled {
+		maxKeep = max(maxKeep, longestPrefixSuffix(p.pending, thinkingStartTag))
+	}
+	if p.config.TriggerSignal != "" {
+		maxKeep = max(maxKeep, longestPrefixSuffix(p.pending, p.config.TriggerSignal))
+	}
+	return maxKeep
+}
+
+func (p *CursorProtocolParser) tryParseThinking(final bool) (models.AssistantEvent, bool) {
+	if !strings.HasPrefix(p.pending, thinkingStartTag) {
+		return models.AssistantEvent{}, false
+	}
+
+	endIdx := strings.Index(p.pending[len(thinkingStartTag):], thinkingEndTag)
+	if endIdx < 0 {
+		if final {
+			return models.AssistantEvent{
+				Kind: models.AssistantEventText,
+				Text: p.pending,
+			}, true
+		}
+		return models.AssistantEvent{}, false
+	}
+
+	start := len(thinkingStartTag)
+	end := start + endIdx
+	content := p.pending[start:end]
+	p.pending = p.pending[end+len(thinkingEndTag):]
+	return models.AssistantEvent{
+		Kind:     models.AssistantEventThinking,
+		Thinking: content,
+	}, true
+}
+
+func (p *CursorProtocolParser) tryParseToolCall(final bool) (models.AssistantEvent, bool) {
+	if p.config.TriggerSignal == "" || !strings.HasPrefix(p.pending, p.config.TriggerSignal) {
+		return models.AssistantEvent{}, false
+	}
+
+	endIdx := strings.Index(p.pending, invokeEndTag)
+	if endIdx < 0 {
+		if final {
+			return models.AssistantEvent{
+				Kind: models.AssistantEventText,
+				Text: p.pending,
+			}, true
+		}
+		return models.AssistantEvent{}, false
+	}
+
+	segment := p.pending[:endIdx+len(invokeEndTag)]
+	call, ok := parseToolCallSegment(segment, p.config.TriggerSignal)
+	p.pending = p.pending[endIdx+len(invokeEndTag):]
+	if !ok {
+		return models.AssistantEvent{
+			Kind: models.AssistantEventText,
+			Text: segment,
+		}, true
+	}
+
+	return models.AssistantEvent{
+		Kind:     models.AssistantEventToolCall,
+		ToolCall: call,
+	}, true
+}
+
+func parseToolCallSegment(segment, triggerSignal string) (*models.ToolCall, bool) {
+	body := strings.TrimSpace(strings.TrimPrefix(segment, triggerSignal))
+	if !strings.HasPrefix(body, "<invoke") {
+		return nil, false
+	}
+
+	openEnd := strings.Index(body, ">")
+	if openEnd < 0 {
+		return nil, false
+	}
+	openTag := body[:openEnd+1]
+	if !strings.HasSuffix(body, invokeEndTag) {
+		return nil, false
+	}
+
+	name := extractInvokeName(openTag)
+	if name == "" {
+		return nil, false
+	}
+
+	args := strings.TrimSpace(body[openEnd+1 : len(body)-len(invokeEndTag)])
+	if args == "" {
+		args = "{}"
+	}
+
+	var compact bytes.Buffer
+	if err := json.Compact(&compact, []byte(args)); err != nil {
+		return nil, false
+	}
+
+	return &models.ToolCall{
+		ID:   "call_" + GenerateRandomString(24),
+		Type: "function",
+		Function: models.FunctionCall{
+			Name:      name,
+			Arguments: compact.String(),
+		},
+	}, true
+}
+
+func extractInvokeName(openTag string) string {
+	nameIdx := strings.Index(openTag, `name="`)
+	if nameIdx < 0 {
+		return ""
+	}
+	value := openTag[nameIdx+len(`name="`):]
+	endIdx := strings.Index(value, `"`)
+	if endIdx < 0 {
+		return ""
+	}
+	return strings.TrimSpace(value[:endIdx])
+}
+
+func longestPrefixSuffix(text, token string) int {
+	maxLen := min(len(text), len(token)-1)
+	for size := maxLen; size > 0; size-- {
+		if strings.HasSuffix(text, token[:size]) {
+			return size
+		}
+	}
+	return 0
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

utils/cursor_protocol_test.go

@@ -0,0 +1,123 @@
+package utils
+
+import (
+	"github.com/libaxuan/cursor2api-go/models"
+	"encoding/json"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+)
+
+func TestCursorProtocolParserParsesThinkingAndToolCallsAcrossChunks(t *testing.T) {
+	parser := NewCursorProtocolParser(models.CursorParseConfig{
+		TriggerSignal:   "<<CALL_test>>",
+		ThinkingEnabled: true,
+	})
+
+	var events []models.AssistantEvent
+	events = append(events, parser.Feed("Hello <think")...)
+	events = append(events, parser.Feed("ing>draft</thinking> world ")...)
+	events = append(events, parser.Feed("<<CALL_test>>\n<invoke name=\"lookup\">{\"q\":\"hel")...)
+	events = append(events, parser.Feed("lo\"}</invoke>!")...)
+	events = append(events, parser.Finish()...)
+
+	if len(events) != 5 {
+		t.Fatalf("event count = %v, want 5", len(events))
+	}
+	if events[0].Kind != models.AssistantEventText || events[0].Text != "Hello " {
+		t.Fatalf("event[0] = %#v, want text Hello", events[0])
+	}
+	if events[1].Kind != models.AssistantEventThinking || events[1].Thinking != "draft" {
+		t.Fatalf("event[1] = %#v, want thinking draft", events[1])
+	}
+	if events[2].Kind != models.AssistantEventText || events[2].Text != " world " {
+		t.Fatalf("event[2] = %#v, want text world", events[2])
+	}
+	if events[3].Kind != models.AssistantEventToolCall || events[3].ToolCall == nil {
+		t.Fatalf("event[3] = %#v, want tool call", events[3])
+	}
+	if events[3].ToolCall.Function.Name != "lookup" {
+		t.Fatalf("tool name = %v, want lookup", events[3].ToolCall.Function.Name)
+	}
+	if events[3].ToolCall.Function.Arguments != `{"q":"hello"}` {
+		t.Fatalf("tool arguments = %v, want compact json", events[3].ToolCall.Function.Arguments)
+	}
+	if events[4].Kind != models.AssistantEventText || events[4].Text != "!" {
+		t.Fatalf("event[4] = %#v, want trailing exclamation text", events[4])
+	}
+}
+
+func TestNonStreamChatCompletionReturnsToolCalls(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	recorder := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(recorder)
+	ctx.Request = httptest.NewRequest("POST", "/v1/chat/completions", nil)
+
+	ch := make(chan interface{}, 4)
+	ch <- models.AssistantEvent{Kind: models.AssistantEventText, Text: "Let me check."}
+	ch <- models.AssistantEvent{
+		Kind: models.AssistantEventToolCall,
+		ToolCall: &models.ToolCall{
+			ID:   "call_1",
+			Type: "function",
+			Function: models.FunctionCall{
+				Name:      "lookup",
+				Arguments: `{"q":"revivalquant"}`,
+			},
+		},
+	}
+	ch <- models.Usage{PromptTokens: 10, CompletionTokens: 5, TotalTokens: 15}
+	close(ch)
+
+	NonStreamChatCompletion(ctx, ch, "claude-sonnet-4.6")
+
+	var response models.ChatCompletionResponse
+	if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
+		t.Fatalf("unmarshal response: %v", err)
+	}
+	if response.Choices[0].FinishReason != "tool_calls" {
+		t.Fatalf("finish reason = %v, want tool_calls", response.Choices[0].FinishReason)
+	}
+	if response.Choices[0].Message.ToolCalls[0].Function.Name != "lookup" {
+		t.Fatalf("tool call name = %v, want lookup", response.Choices[0].Message.ToolCalls[0].Function.Name)
+	}
+	if response.Choices[0].Message.Content != "Let me check." {
+		t.Fatalf("message content = %#v, want Let me check.", response.Choices[0].Message.Content)
+	}
+}
+
+func TestStreamChatCompletionEmitsToolCallChunks(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	recorder := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(recorder)
+	ctx.Request = httptest.NewRequest("POST", "/v1/chat/completions", nil)
+
+	ch := make(chan interface{}, 2)
+	ch <- models.AssistantEvent{
+		Kind: models.AssistantEventToolCall,
+		ToolCall: &models.ToolCall{
+			ID:   "call_1",
+			Type: "function",
+			Function: models.FunctionCall{
+				Name:      "lookup",
+				Arguments: `{"q":"revivalquant"}`,
+			},
+		},
+	}
+	close(ch)
+
+	StreamChatCompletion(ctx, ch, "claude-sonnet-4.6")
+
+	body := recorder.Body.String()
+	if !strings.Contains(body, `"tool_calls":[{"index":0,"id":"call_1","type":"function"`) {
+		t.Fatalf("stream body missing tool_calls delta: %s", body)
+	}
+	if !strings.Contains(body, `"finish_reason":"tool_calls"`) {
+		t.Fatalf("stream body missing tool_calls finish reason: %s", body)
+	}
+	if !strings.Contains(body, "[DONE]") {
+		t.Fatalf("stream body missing DONE marker: %s", body)
+	}
+}

utils/headers.go

@@ -0,0 +1,276 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package utils
+
+import (
+	"fmt"
+	"math/rand"
+	"runtime"
+	"time"
+)
+
+// BrowserProfile 浏览器配置文件
+type BrowserProfile struct {
+	Platform        string
+	PlatformVersion string
+	Architecture    string
+	Bitness         string
+	ChromeVersion   int
+	UserAgent       string
+	Mobile          bool
+}
+
+var (
+	// 常见的浏览器版本 (Chrome)
+	chromeVersions = []int{120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130}
+
+	// Windows 平台配置
+	windowsProfiles = []BrowserProfile{
+		{Platform: "Windows", PlatformVersion: "10.0.0", Architecture: "x86", Bitness: "64"},
+		{Platform: "Windows", PlatformVersion: "11.0.0", Architecture: "x86", Bitness: "64"},
+		{Platform: "Windows", PlatformVersion: "15.0.0", Architecture: "x86", Bitness: "64"},
+	}
+
+	// macOS 平台配置
+	macosProfiles = []BrowserProfile{
+		{Platform: "macOS", PlatformVersion: "13.0.0", Architecture: "arm", Bitness: "64"},
+		{Platform: "macOS", PlatformVersion: "14.0.0", Architecture: "arm", Bitness: "64"},
+		{Platform: "macOS", PlatformVersion: "15.0.0", Architecture: "arm", Bitness: "64"},
+		{Platform: "macOS", PlatformVersion: "13.0.0", Architecture: "x86", Bitness: "64"},
+		{Platform: "macOS", PlatformVersion: "14.0.0", Architecture: "x86", Bitness: "64"},
+	}
+
+	// Linux 平台配置
+	linuxProfiles = []BrowserProfile{
+		{Platform: "Linux", PlatformVersion: "", Architecture: "x86", Bitness: "64"},
+	}
+)
+
+// HeaderGenerator 动态 header 生成器
+type HeaderGenerator struct {
+	profile       BrowserProfile
+	chromeVersion int
+	rng           *rand.Rand
+}
+
+// NewHeaderGenerator 创建新的 header 生成器
+func NewHeaderGenerator() *HeaderGenerator {
+	// 使用当前时间作为随机种子
+	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	// 根据当前操作系统选择合适的配置文件
+	var profiles []BrowserProfile
+	switch runtime.GOOS {
+	case "darwin":
+		profiles = macosProfiles
+	case "linux":
+		profiles = linuxProfiles
+	default:
+		profiles = windowsProfiles
+	}
+
+	// 随机选择一个配置文件
+	profile := profiles[rng.Intn(len(profiles))]
+
+	// 随机选择 Chrome 版本
+	chromeVersion := chromeVersions[rng.Intn(len(chromeVersions))]
+	profile.ChromeVersion = chromeVersion
+
+	// 生成 User-Agent
+	profile.UserAgent = generateUserAgent(profile)
+
+	return &HeaderGenerator{
+		profile:       profile,
+		chromeVersion: chromeVersion,
+		rng:           rng,
+	}
+}
+
+// generateUserAgent 生成 User-Agent 字符串
+func generateUserAgent(profile BrowserProfile) string {
+	switch profile.Platform {
+	case "Windows":
+		return fmt.Sprintf("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.0.0 Safari/537.36", profile.ChromeVersion)
+	case "macOS":
+		if profile.Architecture == "arm" {
+			return fmt.Sprintf("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.0.0 Safari/537.36", profile.ChromeVersion)
+		}
+		return fmt.Sprintf("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.0.0 Safari/537.36", profile.ChromeVersion)
+	case "Linux":
+		return fmt.Sprintf("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.0.0 Safari/537.36", profile.ChromeVersion)
+	default:
+		return fmt.Sprintf("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.0.0 Safari/537.36", profile.ChromeVersion)
+	}
+}
+
+// GetChatHeaders 获取聊天请求的 headers
+func (g *HeaderGenerator) GetChatHeaders(xIsHuman string) map[string]string {
+	// 随机选择语言
+	languages := []string{
+		"en-US,en;q=0.9",
+		"zh-CN,zh;q=0.9,en;q=0.8",
+		"en-GB,en;q=0.9",
+	}
+	lang := languages[g.rng.Intn(len(languages))]
+
+	// 随机选择 referer
+	referers := []string{
+		"https://cursor.com/en-US/learn/how-ai-models-work",
+		"https://cursor.com/cn/learn/how-ai-models-work",
+		"https://cursor.com/",
+	}
+	referer := referers[g.rng.Intn(len(referers))]
+
+	headers := map[string]string{
+		"sec-ch-ua-platform": fmt.Sprintf(`"%s"`, g.profile.Platform),
+		"x-path":             "/api/chat",
+		"Referer":            referer,
+		"sec-ch-ua":          g.getSecChUa(),
+		"x-method":           "POST",
+		"sec-ch-ua-mobile":   "?0",
+		"x-is-human":         xIsHuman,
+		"User-Agent":         g.profile.UserAgent,
+		"content-type":       "application/json",
+		"accept-language":    lang,
+	}
+
+	// 添加可选的 headers
+	if g.profile.Architecture != "" {
+		headers["sec-ch-ua-arch"] = fmt.Sprintf(`"%s"`, g.profile.Architecture)
+	}
+	if g.profile.Bitness != "" {
+		headers["sec-ch-ua-bitness"] = fmt.Sprintf(`"%s"`, g.profile.Bitness)
+	}
+	if g.profile.PlatformVersion != "" {
+		headers["sec-ch-ua-platform-version"] = fmt.Sprintf(`"%s"`, g.profile.PlatformVersion)
+	}
+
+	return headers
+}
+
+// GetScriptHeaders 获取脚本请求的 headers
+func (g *HeaderGenerator) GetScriptHeaders() map[string]string {
+	// 随机选择语言
+	languages := []string{
+		"en-US,en;q=0.9",
+		"zh-CN,zh;q=0.9,en;q=0.8",
+		"en-GB,en;q=0.9",
+	}
+	lang := languages[g.rng.Intn(len(languages))]
+
+	// 随机选择 referer
+	referers := []string{
+		"https://cursor.com/cn/learn/how-ai-models-work",
+		"https://cursor.com/en-US/learn/how-ai-models-work",
+		"https://cursor.com/",
+	}
+	referer := referers[g.rng.Intn(len(referers))]
+
+	headers := map[string]string{
+		"User-Agent":         g.profile.UserAgent,
+		"sec-ch-ua-arch":     fmt.Sprintf(`"%s"`, g.profile.Architecture),
+		"sec-ch-ua-platform": fmt.Sprintf(`"%s"`, g.profile.Platform),
+		"sec-ch-ua":          g.getSecChUa(),
+		"sec-ch-ua-bitness":  fmt.Sprintf(`"%s"`, g.profile.Bitness),
+		"sec-ch-ua-mobile":   "?0",
+		"sec-fetch-site":     "same-origin",
+		"sec-fetch-mode":     "no-cors",
+		"sec-fetch-dest":     "script",
+		"referer":            referer,
+		"accept-language":    lang,
+	}
+
+	if g.profile.PlatformVersion != "" {
+		headers["sec-ch-ua-platform-version"] = fmt.Sprintf(`"%s"`, g.profile.PlatformVersion)
+	}
+
+	return headers
+}
+
+// getSecChUa 生成 sec-ch-ua header
+func (g *HeaderGenerator) getSecChUa() string {
+	// 生成随机的品牌版本
+	notABrand := 24 + g.rng.Intn(10) // 24-33
+
+	return fmt.Sprintf(`"Google Chrome";v="%d", "Chromium";v="%d", "Not(A:Brand";v="%d"`,
+		g.chromeVersion, g.chromeVersion, notABrand)
+}
+
+// GetUserAgent 获取 User-Agent
+func (g *HeaderGenerator) GetUserAgent() string {
+	return g.profile.UserAgent
+}
+
+// GetProfile 获取浏览器配置文件
+func (g *HeaderGenerator) GetProfile() BrowserProfile {
+	return g.profile
+}
+
+// Refresh 刷新配置文件（生成新的随机配置）
+func (g *HeaderGenerator) Refresh() {
+	// 根据当前操作系统选择合适的配置文件
+	var profiles []BrowserProfile
+	switch runtime.GOOS {
+	case "darwin":
+		profiles = macosProfiles
+	case "linux":
+		profiles = linuxProfiles
+	default:
+		profiles = windowsProfiles
+	}
+
+	// 随机选择一个配置文件
+	profile := profiles[g.rng.Intn(len(profiles))]
+
+	// 随机选择 Chrome 版本
+	chromeVersion := chromeVersions[g.rng.Intn(len(chromeVersions))]
+	profile.ChromeVersion = chromeVersion
+
+	// 生成 User-Agent
+	profile.UserAgent = generateUserAgent(profile)
+
+	g.profile = profile
+	g.chromeVersion = chromeVersion
+}
+
+// GetRandomReferer 获取随机 referer
+func GetRandomReferer() string {
+	referers := []string{
+		"https://cursor.com/en-US/learn/how-ai-models-work",
+		"https://cursor.com/cn/learn/how-ai-models-work",
+		"https://cursor.com/",
+		"https://cursor.com/features",
+	}
+	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
+	return referers[rng.Intn(len(referers))]
+}
+
+// GetRandomLanguage 获取随机语言设置
+func GetRandomLanguage() string {
+	languages := []string{
+		"en-US,en;q=0.9",
+		"zh-CN,zh;q=0.9,en;q=0.8",
+		"en-GB,en;q=0.9",
+		"ja-JP,ja;q=0.9,en;q=0.8",
+	}
+	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
+	return languages[rng.Intn(len(languages))]
+}

utils/utils.go

@@ -0,0 +1,501 @@
+// Copyright (c) 2025-2026 libaxuan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package utils
+
+import (
+	"bufio"
+	"context"
+	"crypto/rand"
+	"github.com/libaxuan/cursor2api-go/middleware"
+	"github.com/libaxuan/cursor2api-go/models"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os/exec"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+// GenerateRandomString 生成指定长度的随机字符串
+func GenerateRandomString(length int) string {
+	if length <= 0 {
+		return ""
+	}
+
+	byteLen := (length + 1) / 2
+	bytes := make([]byte, byteLen)
+	if _, err := rand.Read(bytes); err != nil {
+		fallback := fmt.Sprintf("%d", time.Now().UnixNano())
+		if len(fallback) >= length {
+			return fallback[:length]
+		}
+		return fallback
+	}
+
+	encoded := hex.EncodeToString(bytes)
+	if len(encoded) < length {
+		encoded += GenerateRandomString(length - len(encoded))
+	}
+
+	return encoded[:length]
+}
+
+// GenerateChatCompletionID 生成聊天完成ID
+func GenerateChatCompletionID() string {
+	return "chatcmpl-" + GenerateRandomString(29)
+}
+
+// GenerateResponseID 生成 Responses API 响应ID
+func GenerateResponseID() string {
+	return "resp_" + GenerateRandomString(24)
+}
+
+// GenerateResponseItemID 生成 Responses API 输出项ID
+func GenerateResponseItemID(prefix string) string {
+	if prefix == "" {
+		prefix = "item_"
+	}
+	return prefix + GenerateRandomString(24)
+}
+
+// ParseSSELine 解析SSE数据行
+func ParseSSELine(line string) string {
+	line = strings.TrimSpace(line)
+	if strings.HasPrefix(line, "data: ") {
+		return strings.TrimSpace(line[6:]) // 去掉 'data: ' 前缀并去除前导空格
+	}
+	return ""
+}
+
+// WriteSSEEvent 写入SSE事件
+func WriteSSEEvent(w http.ResponseWriter, event, data string) error {
+	if event != "" {
+		if _, err := fmt.Fprintf(w, "event: %s\n", event); err != nil {
+			return err
+		}
+	}
+	if _, err := fmt.Fprintf(w, "data: %s\n\n", data); err != nil {
+		return err
+	}
+
+	// 刷新缓冲区
+	if flusher, ok := w.(http.Flusher); ok {
+		flusher.Flush()
+	}
+
+	return nil
+}
+
+// StreamChatCompletion 处理流式聊天完成
+// StreamChatCompletion 处理流式聊天完成
+func StreamChatCompletion(c *gin.Context, chatGenerator <-chan interface{}, modelName string) {
+	// 设置SSE头
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+	c.Header("Access-Control-Allow-Origin", "*")
+
+	// 生成响应ID
+	responseID := GenerateChatCompletionID()
+	started := false
+	toolCallIndex := 0
+
+	writeChunk := func(delta models.StreamDelta, finishReason *string) {
+		streamResp := models.NewChatCompletionStreamResponse(responseID, modelName, delta, finishReason)
+		if jsonData, err := json.Marshal(streamResp); err == nil {
+			WriteSSEEvent(c.Writer, "", string(jsonData))
+		}
+	}
+
+	// 处理流式数据
+	ctx := c.Request.Context()
+	for {
+		select {
+		case <-ctx.Done():
+			logrus.Debug("Client disconnected during streaming")
+			return
+
+		case data, ok := <-chatGenerator:
+			if !ok {
+				// 通道关闭，发送完成事件
+				reason := "stop"
+				if toolCallIndex > 0 {
+					reason = "tool_calls"
+				}
+				writeChunk(models.StreamDelta{}, stringPtr(reason))
+				WriteSSEEvent(c.Writer, "", "[DONE]")
+				return
+			}
+
+			switch v := data.(type) {
+			case models.AssistantEvent:
+				if !started {
+					writeChunk(models.StreamDelta{Role: "assistant"}, nil)
+					started = true
+				}
+
+				switch v.Kind {
+				case models.AssistantEventText:
+					if v.Text != "" {
+						writeChunk(models.StreamDelta{Content: v.Text}, nil)
+					}
+				case models.AssistantEventToolCall:
+					if v.ToolCall != nil {
+						writeChunk(models.StreamDelta{
+							ToolCalls: []models.ToolCallDelta{
+								{
+									Index: toolCallIndex,
+									ID:    v.ToolCall.ID,
+									Type:  v.ToolCall.Type,
+									Function: &models.FunctionCallDelta{
+										Name:      v.ToolCall.Function.Name,
+										Arguments: v.ToolCall.Function.Arguments,
+									},
+								},
+							},
+						}, nil)
+						toolCallIndex++
+					}
+				}
+			case string:
+				if !started {
+					writeChunk(models.StreamDelta{Role: "assistant"}, nil)
+					started = true
+				}
+				if v != "" {
+					writeChunk(models.StreamDelta{Content: v}, nil)
+				}
+
+			case models.Usage:
+				// 使用统计 - 通常在最后发送
+				continue
+
+			case error:
+				logrus.WithError(v).Error("Stream generator error")
+				WriteSSEEvent(c.Writer, "", "[DONE]")
+				return
+
+			default:
+				logrus.Warnf("Unknown data type in stream: %T", v)
+			}
+		}
+	}
+}
+
+// NonStreamChatCompletion 处理非流式聊天完成
+func NonStreamChatCompletion(c *gin.Context, chatGenerator <-chan interface{}, modelName string) {
+	var fullContent strings.Builder
+	var usage models.Usage
+	toolCalls := make([]models.ToolCall, 0, 2)
+	finishReason := "stop"
+
+	// 收集所有数据
+	ctx := c.Request.Context()
+	for {
+		select {
+		case <-ctx.Done():
+			c.JSON(http.StatusRequestTimeout, models.NewErrorResponse(
+				"Request timeout",
+				"timeout_error",
+				"request_timeout",
+			))
+			return
+
+		case data, ok := <-chatGenerator:
+			if !ok {
+				// 数据收集完成，返回响应
+				responseID := GenerateChatCompletionID()
+				message := models.Message{
+					Role: "assistant",
+				}
+				if fullContent.Len() > 0 || len(toolCalls) == 0 {
+					message.Content = fullContent.String()
+				}
+				if len(toolCalls) > 0 {
+					message.ToolCalls = toolCalls
+					finishReason = "tool_calls"
+				}
+				response := models.NewChatCompletionResponse(
+					responseID,
+					modelName,
+					message,
+					finishReason,
+					usage,
+				)
+				c.JSON(http.StatusOK, response)
+				return
+			}
+
+			switch v := data.(type) {
+			case models.AssistantEvent:
+				switch v.Kind {
+				case models.AssistantEventText:
+					fullContent.WriteString(v.Text)
+				case models.AssistantEventToolCall:
+					if v.ToolCall != nil {
+						toolCalls = append(toolCalls, *v.ToolCall)
+					}
+				}
+			case string:
+				fullContent.WriteString(v)
+			case models.Usage:
+				usage = v
+			case error:
+				middleware.HandleError(c, v)
+				return
+			}
+		}
+	}
+}
+
+// ErrorWrapper 错误包装器
+func ErrorWrapper(handler func(*gin.Context) error) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := handler(c); err != nil {
+			logrus.WithError(err).Error("Handler error")
+
+			if !c.Writer.Written() {
+				c.JSON(http.StatusInternalServerError, models.NewErrorResponse(
+					"Internal server error",
+					"internal_error",
+					"",
+				))
+			}
+		}
+	}
+}
+
+// SafeStreamWrapper 安全流式包装器
+func SafeStreamWrapper(handler func(*gin.Context, <-chan interface{}, string), c *gin.Context, chatGenerator <-chan interface{}, modelName string) {
+	defer func() {
+		if r := recover(); r != nil {
+			logrus.WithField("panic", r).Error("Panic in stream handler")
+			if !c.Writer.Written() {
+				c.JSON(http.StatusInternalServerError, models.NewErrorResponse(
+					"Internal server error",
+					"panic_error",
+					"",
+				))
+			}
+		}
+	}()
+
+	firstItem, ok := <-chatGenerator
+	if !ok {
+		middleware.HandleError(c, middleware.NewCursorWebError(http.StatusInternalServerError, "empty stream"))
+		return
+	}
+
+	if err, isErr := firstItem.(error); isErr {
+		middleware.HandleError(c, err)
+		return
+	}
+
+	buffered := make(chan interface{}, 1)
+	buffered <- firstItem
+	ctx := c.Request.Context()
+
+	go func() {
+		defer close(buffered)
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case item, ok := <-chatGenerator:
+				if !ok {
+					return
+				}
+				select {
+				case buffered <- item:
+				case <-ctx.Done():
+					return
+				}
+			}
+		}
+	}()
+
+	handler(c, buffered, modelName)
+}
+
+// CreateHTTPClient 创建HTTP客户端
+func CreateHTTPClient(timeout time.Duration) *http.Client {
+	return &http.Client{
+		Timeout: timeout,
+		Transport: &http.Transport{
+			Proxy:               http.ProxyFromEnvironment,
+			MaxIdleConns:        100,
+			MaxIdleConnsPerHost: 10,
+			IdleConnTimeout:     90 * time.Second,
+		},
+	}
+}
+
+// ReadSSEStream 读取SSE流
+func ReadSSEStream(ctx context.Context, resp *http.Response, output chan<- interface{}) error {
+	scanner := bufio.NewScanner(resp.Body)
+	scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+	defer resp.Body.Close()
+
+	for scanner.Scan() {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+		}
+
+		line := scanner.Text()
+		data := ParseSSELine(line)
+		if data == "" {
+			continue
+		}
+
+		if data == "[DONE]" {
+			return nil
+		}
+
+		// 尝试解析JSON数据
+		var eventData models.CursorEventData
+		if err := json.Unmarshal([]byte(data), &eventData); err != nil {
+			logrus.WithError(err).Debugf("Failed to parse SSE data: %s", data)
+			continue
+		}
+
+		// 处理不同类型的事件
+		switch eventData.Type {
+		case "error":
+			if eventData.ErrorText != "" {
+				return fmt.Errorf("cursor API error: %s", eventData.ErrorText)
+			}
+
+		case "finish":
+			if eventData.MessageMetadata != nil && eventData.MessageMetadata.Usage != nil {
+				usage := models.Usage{
+					PromptTokens:     eventData.MessageMetadata.Usage.InputTokens,
+					CompletionTokens: eventData.MessageMetadata.Usage.OutputTokens,
+					TotalTokens:      eventData.MessageMetadata.Usage.TotalTokens,
+				}
+				output <- usage
+			}
+			return nil
+
+		default:
+			if eventData.Delta != "" {
+				output <- eventData.Delta
+			}
+		}
+	}
+
+	return scanner.Err()
+}
+
+// ValidateModel 验证模型名称
+func ValidateModel(model string, validModels []string) bool {
+	for _, validModel := range validModels {
+		if validModel == model {
+			return true
+		}
+	}
+	return false
+}
+
+// SanitizeContent 清理内容
+func SanitizeContent(content string) string {
+	// 移除可能的恶意内容
+	content = strings.ReplaceAll(content, "\x00", "")
+	return content
+}
+
+// stringPtr 返回字符串指针
+func stringPtr(s string) *string {
+	return &s
+}
+
+// CopyHeaders 复制HTTP头
+func CopyHeaders(dst, src http.Header, skipHeaders []string) {
+	skipMap := make(map[string]bool)
+	for _, header := range skipHeaders {
+		skipMap[strings.ToLower(header)] = true
+	}
+
+	for key, values := range src {
+		if skipMap[strings.ToLower(key)] {
+			continue
+		}
+		for _, value := range values {
+			dst.Add(key, value)
+		}
+	}
+}
+
+// IsJSONContentType 检查是否为JSON内容类型
+func IsJSONContentType(contentType string) bool {
+	return strings.Contains(strings.ToLower(contentType), "application/json")
+}
+
+// ReadRequestBody 读取请求体
+func ReadRequestBody(r *http.Request) ([]byte, error) {
+	if r.Body == nil {
+		return nil, nil
+	}
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read request body: %w", err)
+	}
+
+	return body, nil
+}
+
+// RunJS 执行JavaScript代码并返回标准输出内容
+func RunJS(jsCode string) (string, error) {
+	// 添加crypto模块导入并设置为全局变量
+	// 注意：使用stdin时，我们需要确保代码是自包含的
+	finalJS := `const crypto = require('crypto').webcrypto;
+global.crypto = crypto;
+globalThis.crypto = crypto;
+// 在Node.js环境中创建window对象
+if (typeof window === 'undefined') { global.window = global; }
+window.crypto = crypto;
+this.crypto = crypto;
+` + jsCode
+
+	// 执行Node.js命令，使用stdin输入代码
+	cmd := exec.Command("node")
+
+	// 设置输入
+	cmd.Stdin = strings.NewReader(finalJS)
+
+	output, err := cmd.Output()
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			return "", fmt.Errorf("node.js execution failed (exit code: %d)\nSTDOUT:\n%s\nSTDERR:\n%s",
+				exitErr.ExitCode(), string(output), string(exitErr.Stderr))
+		}
+		return "", fmt.Errorf("failed to execute node.js: %w", err)
+	}
+
+	return strings.TrimSpace(string(output)), nil
+}