Update from GitHub Actions

.env.example

@@ -0,0 +1,24 @@
+# JetBrains AI Proxy 多JWT配置示例
+
+# 方式1: 使用多个JWT tokens（推荐）
+# 多个tokens用逗号分隔，系统会自动进行负载均衡
+JWT_TOKENS=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...,eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...,eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...
+
+# 方式2: 使用单个JWT token（向后兼容）
+# JWT_TOKEN=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...
+
+# Bearer Token（必需）
+BEARER_TOKEN=your_bearer_token_here
+
+# 负载均衡策略（可选）
+# round_robin: 轮询策略（默认）
+# random: 随机策略
+LOAD_BALANCE_STRATEGY=round_robin
+
+# 使用说明:
+# 1. 复制此文件为 .env
+# 2. 替换上面的示例值为真实的tokens
+# 3. 启动服务: ./jetbrains-ai-proxy
+#
+# 或者使用命令行参数:
+# ./jetbrains-ai-proxy -c "jwt1,jwt2,jwt3" -k "bearer_token" -s "random" -p 8080

CONFIGURATION_SYSTEM.md

@@ -0,0 +1,274 @@
+# 统一配置系统说明
+
+JetBrains AI Proxy现在采用了全新的统一配置系统，实现了自动配置发现、多种配置方式支持和配置热重载等功能。
+
+## 🏗️ 系统架构
+
+### 核心组件
+
+1. **ConfigManager** (`internal/config/config.go`)
+   - 统一的配置管理器
+   - 支持多种配置源的合并
+   - 线程安全的配置访问
+   - 配置验证和默认值处理
+
+2. **ConfigDiscovery** (`internal/config/discovery.go`)
+   - 自动配置文件发现
+   - 配置文件格式验证
+   - 配置文件监控和热重载
+   - 示例配置生成
+
+3. **JWTBalancer** (`internal/balancer/jwt_balancer.go`)
+   - JWT负载均衡器
+   - 支持轮询和随机策略
+   - 并发安全的token管理
+   - 动态token更新
+
+4. **HealthChecker** (`internal/balancer/health_checker.go`)
+   - JWT健康检查器
+   - 自动故障检测和恢复
+   - 可配置的检查间隔
+   - 并发健康检查
+
+## 📁 文件结构
+
+```
+jetbrains-ai-proxy/
+├── main.go                          # 主程序，支持新配置系统
+├── start.sh                         # 智能启动脚本
+├── CONFIGURATION_SYSTEM.md          # 配置系统说明（本文件）
+├── MULTI_JWT_README.md              # 多JWT功能说明
+├── internal/
+│   ├── config/
+│   │   ├── config.go                # 配置管理器
+│   │   └── discovery.go             # 配置发现器
+│   ├── balancer/
+│   │   ├── jwt_balancer.go          # JWT负载均衡器
+│   │   ├── health_checker.go        # 健康检查器
+│   │   └── jwt_balancer_test.go     # 测试用例
+│   └── jetbrains/
+│       └── client.go                # 集成配置系统的客户端
+└── examples/
+    ├── complete_example.md          # 完整使用示例
+    ├── start_with_multiple_jwt.sh   # 多JWT启动脚本
+    └── .env.example                 # 环境变量示例
+```
+
+## ⚙️ 配置优先级
+
+系统按以下优先级加载和合并配置：
+
+1. **命令行参数** (最高优先级)
+2. **环境变量**
+3. **配置文件**
+4. **默认值** (最低优先级)
+
+## 🔍 配置发现机制
+
+系统会按以下顺序搜索配置文件：
+
+1. `CONFIG_FILE` 环境变量指定的路径
+2. 当前目录：`config.json`, `jetbrains-ai-proxy.json`
+3. config目录：`config/config.json`, `configs/config.json`
+4. 隐藏目录：`.config/config.json`
+5. 用户主目录：`$HOME/.config/jetbrains-ai-proxy/config.json`
+6. 系统目录：`/etc/jetbrains-ai-proxy/config.json`
+
+如果没有找到配置文件，系统会自动生成示例配置。
+
+## 🚀 使用方式
+
+### 1. 自动配置（推荐）
+
+```bash
+# 生成示例配置
+./jetbrains-ai-proxy --generate-config
+
+# 编辑配置文件
+vim config/config.json
+
+# 启动服务（自动发现配置）
+./jetbrains-ai-proxy
+```
+
+### 2. 使用启动脚本
+
+```bash
+# 智能启动（自动检查配置）
+./start.sh
+
+# 生成配置
+./start.sh --generate
+
+# 查看配置
+./start.sh --config
+```
+
+### 3. 指定配置文件
+
+```bash
+# 使用特定配置文件
+./jetbrains-ai-proxy --config /path/to/config.json
+
+# 或设置环境变量
+export CONFIG_FILE=/path/to/config.json
+./jetbrains-ai-proxy
+```
+
+## 📋 配置文件格式
+
+### JSON配置文件示例
+
+```json
+{
+  "jetbrains_tokens": [
+    {
+      "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+      "name": "Primary_JWT",
+      "description": "Primary JWT token for JetBrains AI",
+      "priority": 1,
+      "metadata": {
+        "environment": "production",
+        "region": "us-east-1"
+      }
+    }
+  ],
+  "bearer_token": "your_bearer_token_here",
+  "load_balance_strategy": "round_robin",
+  "health_check_interval": "30s",
+  "server_port": 8080,
+  "server_host": "0.0.0.0"
+}
+```
+
+### 环境变量配置
+
+```bash
+# JWT Tokens（逗号分隔）
+JWT_TOKENS=token1,token2,token3
+
+# Bearer Token
+BEARER_TOKEN=your_bearer_token
+
+# 负载均衡策略
+LOAD_BALANCE_STRATEGY=round_robin
+
+# 服务器配置
+SERVER_HOST=0.0.0.0
+SERVER_PORT=8080
+
+# 配置文件路径（可选）
+CONFIG_FILE=config/config.json
+```
+
+## 🔄 配置热重载
+
+系统支持运行时配置重载，无需重启服务：
+
+### 自动重载
+
+配置文件监控器会自动检测配置文件变化并重新加载。
+
+### 手动重载
+
+```bash
+# 通过API端点重载
+curl -X POST http://localhost:8080/reload
+
+# 响应
+{
+  "message": "Configuration reloaded successfully"
+}
+```
+
+## 🛠️ 管理端点
+
+系统提供了丰富的管理端点：
+
+| 端点 | 方法 | 描述 |
+|------|------|------|
+| `/health` | GET | 健康检查和负载均衡状态 |
+| `/config` | GET | 当前配置信息（隐藏敏感数据） |
+| `/stats` | GET | 详细统计信息 |
+| `/reload` | POST | 重新加载配置 |
+
+## 🔧 高级功能
+
+### 1. JWT Token元数据
+
+支持为每个JWT token配置元数据：
+
+```json
+{
+  "token": "jwt_token_here",
+  "name": "Production_Primary",
+  "description": "Primary production JWT token",
+  "priority": 1,
+  "metadata": {
+    "environment": "production",
+    "region": "us-east-1",
+    "tier": "primary",
+    "max_requests_per_minute": "1000"
+  }
+}
+```
+
+### 2. 配置验证
+
+系统会自动验证配置的有效性：
+- JWT token格式检查
+- 必需字段验证
+- 数值范围检查
+- 策略有效性验证
+
+### 3. 配置合并策略
+
+多个配置源的合并规则：
+- 数组类型：高优先级完全覆盖低优先级
+- 对象类型：递归合并，高优先级字段覆盖低优先级
+- 基本类型：高优先级直接覆盖低优先级
+
+## 🚨 故障排除
+
+### 配置问题诊断
+
+```bash
+# 查看当前配置
+./jetbrains-ai-proxy --print-config
+
+# 验证配置文件
+./jetbrains-ai-proxy --config config.json --print-config
+
+# 生成新的示例配置
+./jetbrains-ai-proxy --generate-config
+```
+
+### 常见问题
+
+1. **配置文件未找到**
+   - 检查文件路径和权限
+   - 使用 `--generate-config` 生成示例配置
+
+2. **JWT tokens无效**
+   - 检查token格式和有效性
+   - 查看健康检查日志
+
+3. **配置合并问题**
+   - 使用 `--print-config` 查看最终配置
+   - 检查配置优先级
+
+## 📈 性能考虑
+
+1. **配置缓存**: 配置在内存中缓存，避免重复读取
+2. **并发安全**: 使用读写锁保护配置访问
+3. **懒加载**: 配置发现器按需加载配置文件
+4. **监控优化**: 配置文件监控使用高效的文件系统事件
+
+## 🔮 未来扩展
+
+系统设计支持以下扩展：
+- 远程配置中心集成（如Consul、etcd）
+- 配置加密和安全存储
+- 配置版本管理和回滚
+- 更多负载均衡策略
+- 动态配置更新API

Dockerfile

@@ -0,0 +1,25 @@
+# Builder Stage - 使用明确的版本并优化缓存
+FROM golang:1.24-alpine as builder
+
+# 设置工作目录
+WORKDIR /app
+
+# 1. 仅复制依赖描述文件
+COPY go.mod go.sum ./
+
+# 2. 下载依赖项。这一步会被缓存，只有在 go.mod/go.sum 变化时才会重新运行
+RUN go mod download
+
+# 3. 复制项目源码
+COPY . .
+
+# 4. 编译应用。现在此步骤将使用缓存的依赖
+RUN go build -o jetbrains-ai-proxy
+
+# Final Stage - 保持不变
+FROM alpine
+LABEL maintainer="zouyq <zyqcn@live.com>"
+
+COPY --from=builder /app/jetbrains-ai-proxy /usr/local/bin/
+
+ENTRYPOINT ["jetbrains-ai-proxy"]

Dockerfile.ci

@@ -0,0 +1,9 @@
+FROM alpine
+LABEL maintainer="zouyq <zyqcn@live.com>"
+
+ARG TARGETOS
+ARG TARGETARCH
+
+COPY dist/jetbrains-ai-proxy-${TARGETOS}-${TARGETARCH} /usr/local/bin/jetbrains-ai-proxy
+
+ENTRYPOINT ["jetbrains-ai-proxy"]

MULTI_JWT_README.md

@@ -0,0 +1,284 @@
+# JetBrains AI Proxy - 多JWT负载均衡系统
+
+本项目提供了一个功能完整的多JWT负载均衡系统，支持自动配置发现、健康检查和故障转移。
+
+## 🎯 核心特性
+
+- ✅ **智能配置管理**: 自动发现和加载配置文件，支持多种配置方式
+- ✅ **多JWT支持**: 支持配置多个JWT tokens进行负载均衡
+- ✅ **负载均衡策略**: 支持轮询(round_robin)和随机(random)两种策略
+- ✅ **健康检查**: 自动检测失效的tokens并从负载均衡池中移除
+- ✅ **故障转移**: 当某个token失效时自动切换到其他健康的token
+- ✅ **配置热重载**: 支持运行时重新加载配置
+- ✅ **并发安全**: 支持高并发环境下的安全使用
+- ✅ **管理端点**: 提供健康检查、配置查看、统计信息等管理接口
+- ✅ **优雅关闭**: 支持优雅关闭和资源清理
+
+## 🚀 快速开始
+
+### 方式1: 使用启动脚本（推荐）
+
+```bash
+# 1. 生成示例配置
+./start.sh --generate
+
+# 2. 编辑配置文件
+vim config/config.json
+# 或编辑环境变量文件
+cp .env.example .env && vim .env
+
+# 3. 启动服务
+./start.sh
+```
+
+### 方式2: 直接使用可执行文件
+
+```bash
+# 生成示例配置
+./jetbrains-ai-proxy --generate-config
+
+# 查看当前配置
+./jetbrains-ai-proxy --print-config
+
+# 启动服务
+./jetbrains-ai-proxy
+```
+
+## ⚙️ 配置方式
+
+系统支持多种配置方式，优先级从高到低：
+
+1. **命令行参数** (最高优先级)
+2. **环境变量**
+3. **配置文件**
+4. **默认值** (最低优先级)
+
+### 1. 配置文件方式（推荐）
+
+系统会自动搜索以下路径的配置文件：
+
+- `config.json`
+- `config/config.json`
+- `configs/config.json`
+- `.config/jetbrains-ai-proxy.json`
+- `$HOME/.config/jetbrains-ai-proxy/config.json`
+
+配置文件示例：
+
+```json
+{
+  "jetbrains_tokens": [
+    {
+      "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+      "name": "Primary_JWT",
+      "description": "Primary JWT token for JetBrains AI",
+      "priority": 1,
+      "metadata": {
+        "environment": "production",
+        "region": "us-east-1"
+      }
+    },
+    {
+      "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+      "name": "Secondary_JWT",
+      "description": "Secondary JWT token for load balancing",
+      "priority": 2,
+      "metadata": {
+        "environment": "production",
+        "region": "us-west-2"
+      }
+    }
+  ],
+  "bearer_token": "your_bearer_token_here",
+  "load_balance_strategy": "round_robin",
+  "health_check_interval": "30s",
+  "server_port": 8080,
+  "server_host": "0.0.0.0"
+}
+```
+
+### 2. 环境变量配置
+
+```bash
+# 多个JWT tokens，用逗号分隔
+export JWT_TOKENS="jwt_token_1,jwt_token_2,jwt_token_3"
+
+# 或者使用旧的单token配置（向后兼容）
+export JWT_TOKEN="single_jwt_token"
+
+# Bearer token
+export BEARER_TOKEN="your_bearer_token"
+
+# 负载均衡策略（可选，默认为round_robin）
+export LOAD_BALANCE_STRATEGY="random"
+
+# 服务器配置
+export SERVER_HOST="0.0.0.0"
+export SERVER_PORT="8080"
+
+# 指定配置文件路径（可选）
+export CONFIG_FILE="path/to/config.json"
+```
+
+### 3. 命令行参数配置
+
+```bash
+# 查看所有选项
+./jetbrains-ai-proxy --help
+
+# 使用命令行参数启动
+./jetbrains-ai-proxy \
+  -c "jwt1,jwt2,jwt3" \
+  -k "bearer_token" \
+  -s "round_robin" \
+  -p 8080 \
+  -h "0.0.0.0"
+
+# 指定配置文件
+./jetbrains-ai-proxy --config config/my-config.json
+```
+
+## 负载均衡策略
+
+### 轮询策略 (round_robin)
+
+- **默认策略**
+- 按顺序依次使用每个健康的JWT token
+- 确保负载均匀分布
+- 适合大多数场景
+
+### 随机策略 (random)
+
+- 随机选择一个健康的JWT token
+- 避免可预测的请求模式
+- 适合需要随机分布的场景
+
+## 健康检查机制
+
+系统会自动进行JWT token健康检查：
+
+- **检查间隔**: 每30秒检查一次
+- **检查方式**: 发送测试请求到JetBrains AI API
+- **故障处理**: 自动标记失效的tokens为不健康状态
+- **恢复机制**: 定期重新检查不健康的tokens
+
+## 监控端点
+
+访问 `/health` 端点可以查看负载均衡器状态：
+
+```bash
+curl http://localhost:8080/health
+```
+
+响应示例：
+
+```json
+{
+  "status": "ok",
+  "healthy_tokens": 2,
+  "total_tokens": 3,
+  "strategy": "round_robin"
+}
+```
+
+## 使用示例
+
+### 启动服务
+
+```bash
+# 使用3个JWT tokens，轮询策略
+./jetbrains-ai-proxy \
+  -p 8080 \
+  -c "eyJ0eXAiOiJKV1QiLCJhbGc...,eyJ0eXAiOiJKV1QiLCJhbGc...,eyJ0eXAiOiJKV1QiLCJhbGc..." \
+  -k "your_bearer_token" \
+  -s "round_robin"
+```
+
+### 发送请求
+
+```bash
+curl -X POST http://localhost:8080/v1/chat/completions \
+  -H "Authorization: Bearer your_bearer_token" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gpt-4o",
+    "messages": [
+      {"role": "user", "content": "Hello, world!"}
+    ],
+    "stream": false
+  }'
+```
+
+## 日志输出
+
+启动时会显示负载均衡器配置信息：
+
+```
+2024/01/01 12:00:00 JWT balancer initialized with 3 tokens, strategy: round_robin
+2024/01/01 12:00:00 JWT health checker started
+2024/01/01 12:00:00 Server starting on 0.0.0.0:8080
+2024/01/01 12:00:00 JWT tokens configured: 3
+2024/01/01 12:00:00 Load balance strategy: round_robin
+```
+
+运行时会显示健康检查和token使用情况：
+
+```
+2024/01/01 12:01:00 Performing JWT health check...
+2024/01/01 12:01:01 Health check completed: 3/3 tokens healthy
+2024/01/01 12:01:30 JWT token marked as unhealthy: eyJ0eXAiOi... (errors: 1)
+2024/01/01 12:02:00 JWT token marked as healthy: eyJ0eXAiOi...
+```
+
+## 故障排除
+
+### 1. 所有tokens都不健康
+
+如果所有JWT tokens都被标记为不健康，请求会返回错误：
+
+```json
+{
+  "error": "no available JWT tokens: no healthy JWT tokens available"
+}
+```
+
+**解决方案**:
+
+- 检查JWT tokens是否有效
+- 检查网络连接
+- 查看健康检查日志
+
+### 2. 部分tokens不健康
+
+系统会自动使用健康的tokens，但建议：
+
+- 检查不健康tokens的有效性
+- 考虑更换失效的tokens
+- 监控健康检查日志
+
+### 3. 性能优化
+
+- 根据实际负载调整JWT tokens数量
+- 选择合适的负载均衡策略
+- 监控 `/health` 端点的响应
+
+## 技术实现
+
+### 核心组件
+
+1. **JWTBalancer**: 负载均衡器接口和实现
+2. **HealthChecker**: JWT健康检查器
+3. **Config**: 配置管理，支持多JWT配置
+4. **Client**: 集成负载均衡器的HTTP客户端
+
+### 并发安全
+
+- 使用读写锁保护共享状态
+- 原子操作处理计数器
+- 线程安全的随机数生成器
+
+### 错误处理
+
+- 自动重试机制
+- 优雅的错误降级
+- 详细的错误日志记录

docker-compose.env.example

@@ -0,0 +1,11 @@
+# JetBrains AI Proxy Docker Compose 配置
+
+# JWT Tokens (必需) - 多个tokens用逗号分隔
+JWT_TOKENS=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...,eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...
+
+# Bearer Token (必需)
+BEARER_TOKEN=your_bearer_token_here
+
+# 负载均衡策略 (可选，默认: round_robin)
+# 可选值: round_robin, random
+LOAD_BALANCE_STRATEGY=round_robin

docker-compose.yml

@@ -0,0 +1,26 @@
+version: '3.8'
+
+services:
+  jetbrains-ai-proxy:
+    build:
+      context: ./jetbrains-ai-proxy
+      dockerfile: Dockerfile
+    container_name: jetbrains-ai-proxy
+    ports:
+      - "8080:8080"
+    environment:
+      - JWT_TOKENS=${JWT_TOKENS}
+      - BEARER_TOKEN=${BEARER_TOKEN}
+      - LOAD_BALANCE_STRATEGY=${LOAD_BALANCE_STRATEGY:-round_robin}
+      - SERVER_HOST=0.0.0.0
+      - SERVER_PORT=8080
+    volumes:
+      - ./jetbrains-ai-proxy/config:/app/config:ro
+      - ./jetbrains-ai-proxy/logs:/app/logs
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8080/health"]
+      interval: 1000s
+      timeout: 30s
+      retries: 3
+      start_period: 40s

examples/.env.example

@@ -0,0 +1,24 @@
+# JetBrains AI Proxy 多JWT配置示例
+
+# 方式1: 使用多个JWT tokens（推荐）
+# 多个tokens用逗号分隔，系统会自动进行负载均衡
+JWT_TOKENS=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...,eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...,eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...
+
+# 方式2: 使用单个JWT token（向后兼容）
+# JWT_TOKEN=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...
+
+# Bearer Token（必需）
+BEARER_TOKEN=your_bearer_token_here
+
+# 负载均衡策略（可选）
+# round_robin: 轮询策略（默认）
+# random: 随机策略
+LOAD_BALANCE_STRATEGY=round_robin
+
+# 使用说明:
+# 1. 复制此文件为 .env
+# 2. 替换上面的示例值为真实的tokens
+# 3. 启动服务: ./jetbrains-ai-proxy
+#
+# 或者使用命令行参数:
+# ./jetbrains-ai-proxy -c "jwt1,jwt2,jwt3" -k "bearer_token" -s "random" -p 8080

examples/complete_example.md

@@ -0,0 +1,348 @@
+# 完整使用示例
+
+本文档提供了JetBrains AI Proxy多JWT负载均衡系统的完整使用示例。
+
+## 📋 准备工作
+
+### 1. 编译项目
+
+```bash
+# 进入项目目录
+cd jetbrains-ai-proxy
+
+# 编译项目
+go build -o jetbrains-ai-proxy
+
+# 或者使用交叉编译
+GOOS=linux GOARCH=amd64 go build -o jetbrains-ai-proxy-linux
+```
+
+### 2. 准备JWT Tokens
+
+确保你有有效的JetBrains AI JWT tokens。你可以从以下途径获取：
+- JetBrains AI服务控制台
+- 现有的JetBrains IDE配置
+- API密钥管理界面
+
+## 🎯 使用场景示例
+
+### 场景1: 开发环境快速启动
+
+```bash
+# 1. 生成示例配置
+./jetbrains-ai-proxy --generate-config
+
+# 2. 编辑配置文件
+vim config/config.json
+
+# 3. 启动服务
+./jetbrains-ai-proxy
+```
+
+配置文件内容：
+```json
+{
+  "jetbrains_tokens": [
+    {
+      "token": "your_jwt_token_here",
+      "name": "Dev_Token",
+      "description": "Development JWT token"
+    }
+  ],
+  "bearer_token": "your_bearer_token_here",
+  "load_balance_strategy": "round_robin",
+  "server_port": 8080,
+  "server_host": "127.0.0.1"
+}
+```
+
+### 场景2: 生产环境多JWT负载均衡
+
+```bash
+# 1. 创建生产配置目录
+mkdir -p /etc/jetbrains-ai-proxy
+
+# 2. 创建生产配置文件
+cat > /etc/jetbrains-ai-proxy/config.json << 'EOF'
+{
+  "jetbrains_tokens": [
+    {
+      "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+      "name": "Primary_Production",
+      "description": "Primary production JWT token",
+      "priority": 1,
+      "metadata": {
+        "environment": "production",
+        "region": "us-east-1",
+        "tier": "primary"
+      }
+    },
+    {
+      "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+      "name": "Secondary_Production",
+      "description": "Secondary production JWT token",
+      "priority": 2,
+      "metadata": {
+        "environment": "production",
+        "region": "us-west-2",
+        "tier": "secondary"
+      }
+    },
+    {
+      "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+      "name": "Backup_Production",
+      "description": "Backup production JWT token",
+      "priority": 3,
+      "metadata": {
+        "environment": "production",
+        "region": "eu-west-1",
+        "tier": "backup"
+      }
+    }
+  ],
+  "bearer_token": "prod_bearer_token_here",
+  "load_balance_strategy": "random",
+  "health_check_interval": "30s",
+  "server_port": 8080,
+  "server_host": "0.0.0.0"
+}
+EOF
+
+# 3. 启动服务
+./jetbrains-ai-proxy --config /etc/jetbrains-ai-proxy/config.json
+```
+
+### 场景3: 使用环境变量配置
+
+```bash
+# 1. 设置环境变量
+export JWT_TOKENS="jwt1,jwt2,jwt3"
+export BEARER_TOKEN="your_bearer_token"
+export LOAD_BALANCE_STRATEGY="random"
+export SERVER_PORT="9090"
+
+# 2. 启动服务
+./jetbrains-ai-proxy
+
+# 或者使用.env文件
+cat > .env << 'EOF'
+JWT_TOKENS=jwt_token_1,jwt_token_2,jwt_token_3
+BEARER_TOKEN=your_bearer_token_here
+LOAD_BALANCE_STRATEGY=round_robin
+SERVER_HOST=0.0.0.0
+SERVER_PORT=8080
+EOF
+
+./jetbrains-ai-proxy
+```
+
+### 场景4: Docker容器部署
+
+```bash
+# 1. 创建Dockerfile（如果不存在）
+cat > Dockerfile << 'EOF'
+FROM golang:1.21-alpine AS builder
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN go build -o jetbrains-ai-proxy
+
+FROM alpine:latest
+RUN apk --no-cache add ca-certificates
+WORKDIR /root/
+COPY --from=builder /app/jetbrains-ai-proxy .
+EXPOSE 8080
+CMD ["./jetbrains-ai-proxy"]
+EOF
+
+# 2. 构建镜像
+docker build -t jetbrains-ai-proxy .
+
+# 3. 运行容器
+docker run -d \
+  --name jetbrains-ai-proxy \
+  -p 8080:8080 \
+  -e JWT_TOKENS="jwt1,jwt2,jwt3" \
+  -e BEARER_TOKEN="your_bearer_token" \
+  -e LOAD_BALANCE_STRATEGY="random" \
+  jetbrains-ai-proxy
+
+# 4. 或者使用配置文件挂载
+docker run -d \
+  --name jetbrains-ai-proxy \
+  -p 8080:8080 \
+  -v $(pwd)/config:/app/config \
+  jetbrains-ai-proxy
+```
+
+## 🔧 管理和监控
+
+### 健康检查
+
+```bash
+# 检查服务状态
+curl http://localhost:8080/health
+
+# 响应示例
+{
+  "status": "ok",
+  "healthy_tokens": 3,
+  "total_tokens": 3,
+  "strategy": "round_robin",
+  "server_info": {
+    "host": "0.0.0.0",
+    "port": 8080
+  }
+}
+```
+
+### 查看配置信息
+
+```bash
+# 查看当前配置
+curl http://localhost:8080/config
+
+# 响应示例
+{
+  "jwt_tokens_count": 3,
+  "jwt_tokens": [
+    {
+      "name": "Primary_JWT",
+      "description": "Primary JWT token",
+      "priority": 1,
+      "token_preview": "eyJ0eXAiOiJKV1QiLCJhbGc..."
+    }
+  ],
+  "bearer_token_set": true,
+  "load_balance_strategy": "round_robin",
+  "health_check_interval": "30s",
+  "server_host": "0.0.0.0",
+  "server_port": 8080
+}
+```
+
+### 查看统计信息
+
+```bash
+# 查看负载均衡统计
+curl http://localhost:8080/stats
+
+# 响应示例
+{
+  "balancer": {
+    "healthy_tokens": 3,
+    "total_tokens": 3,
+    "strategy": "round_robin"
+  },
+  "config": {
+    "health_check_interval": "30s",
+    "server_host": "0.0.0.0",
+    "server_port": 8080
+  }
+}
+```
+
+### 重载配置
+
+```bash
+# 重新加载配置（无需重启服务）
+curl -X POST http://localhost:8080/reload
+
+# 响应示例
+{
+  "message": "Configuration reloaded successfully"
+}
+```
+
+## 🧪 测试API
+
+### 发送聊天请求
+
+```bash
+# 发送非流式请求
+curl -X POST http://localhost:8080/v1/chat/completions \
+  -H "Authorization: Bearer your_bearer_token" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gpt-4o",
+    "messages": [
+      {"role": "user", "content": "Hello, how are you?"}
+    ],
+    "stream": false
+  }'
+
+# 发送流式请求
+curl -X POST http://localhost:8080/v1/chat/completions \
+  -H "Authorization: Bearer your_bearer_token" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gpt-4o",
+    "messages": [
+      {"role": "user", "content": "Tell me a story"}
+    ],
+    "stream": true
+  }'
+```
+
+### 获取支持的模型
+
+```bash
+# 获取模型列表
+curl http://localhost:8080/v1/models \
+  -H "Authorization: Bearer your_bearer_token"
+```
+
+## 🚨 故障排除
+
+### 常见问题
+
+1. **所有JWT tokens都不健康**
+   ```bash
+   # 检查token有效性
+   curl http://localhost:8080/health
+   
+   # 查看日志
+   tail -f /var/log/jetbrains-ai-proxy.log
+   ```
+
+2. **配置文件未找到**
+   ```bash
+   # 生成示例配置
+   ./jetbrains-ai-proxy --generate-config
+   
+   # 检查配置文件路径
+   ./jetbrains-ai-proxy --print-config
+   ```
+
+3. **端口被占用**
+   ```bash
+   # 检查端口使用情况
+   lsof -i :8080
+   
+   # 使用不同端口启动
+   ./jetbrains-ai-proxy -p 9090
+   ```
+
+### 日志分析
+
+```bash
+# 查看实时日志
+tail -f jetbrains-ai-proxy.log
+
+# 过滤健康检查日志
+grep "health check" jetbrains-ai-proxy.log
+
+# 过滤错误日志
+grep -i error jetbrains-ai-proxy.log
+```
+
+## 📈 性能优化建议
+
+1. **JWT Token数量**: 建议配置3-5个JWT tokens以获得最佳负载均衡效果
+2. **健康检查间隔**: 生产环境建议设置为30-60秒
+3. **负载均衡策略**: 
+   - 使用`round_robin`获得均匀分布
+   - 使用`random`避免可预测的请求模式
+4. **监控**: 定期检查`/health`和`/stats`端点
+5. **日志**: 配置适当的日志级别和轮转策略

examples/demo_balancer.go

@@ -0,0 +1,180 @@
+package main
+
+import (
+	"fmt"
+	"jetbrains-ai-proxy/internal/balancer"
+	"jetbrains-ai-proxy/internal/config"
+	"log"
+	"sync"
+	"time"
+)
+
+func main() {
+	fmt.Println("=== JWT负载均衡器演示 ===")
+
+	// 演示轮询策略
+	fmt.Println("\n1. 轮询策略演示:")
+	demoRoundRobin()
+
+	// 演示随机策略
+	fmt.Println("\n2. 随机策略演示:")
+	demoRandom()
+
+	// 演示健康检查
+	fmt.Println("\n3. 健康检查演示:")
+	demoHealthCheck()
+
+	// 演示并发访问
+	fmt.Println("\n4. 并发访问演示:")
+	demoConcurrent()
+
+	fmt.Println("\n=== 演示完成 ===")
+}
+
+func demoRoundRobin() {
+	tokens := []string{"JWT_TOKEN_1", "JWT_TOKEN_2", "JWT_TOKEN_3"}
+	balancer := balancer.NewJWTBalancer(tokens, config.RoundRobin)
+
+	fmt.Printf("配置了 %d 个JWT tokens，使用轮询策略\n", len(tokens))
+	fmt.Println("获取token顺序:")
+
+	for i := 0; i < 9; i++ {
+		token, err := balancer.GetToken()
+		if err != nil {
+			log.Printf("错误: %v", err)
+			continue
+		}
+		fmt.Printf("  第%d次: %s\n", i+1, token)
+	}
+}
+
+func demoRandom() {
+	tokens := []string{"JWT_TOKEN_A", "JWT_TOKEN_B", "JWT_TOKEN_C"}
+	balancer := balancer.NewJWTBalancer(tokens, config.Random)
+
+	fmt.Printf("配置了 %d 个JWT tokens，使用随机策略\n", len(tokens))
+	fmt.Println("获取token顺序:")
+
+	tokenCounts := make(map[string]int)
+	for i := 0; i < 12; i++ {
+		token, err := balancer.GetToken()
+		if err != nil {
+			log.Printf("错误: %v", err)
+			continue
+		}
+		tokenCounts[token]++
+		fmt.Printf("  第%d次: %s\n", i+1, token)
+	}
+
+	fmt.Println("使用统计:")
+	for token, count := range tokenCounts {
+		fmt.Printf("  %s: %d次\n", token, count)
+	}
+}
+
+func demoHealthCheck() {
+	tokens := []string{"JWT_HEALTHY_1", "JWT_HEALTHY_2", "JWT_UNHEALTHY_3"}
+	balancer := balancer.NewJWTBalancer(tokens, config.RoundRobin)
+
+	fmt.Printf("初始状态: %d/%d tokens健康\n",
+		balancer.GetHealthyTokenCount(), balancer.GetTotalTokenCount())
+
+	// 标记一个token为不健康
+	fmt.Println("标记 JWT_UNHEALTHY_3 为不健康...")
+	balancer.MarkTokenUnhealthy("JWT_UNHEALTHY_3")
+
+	fmt.Printf("更新后状态: %d/%d tokens健康\n",
+		balancer.GetHealthyTokenCount(), balancer.GetTotalTokenCount())
+
+	fmt.Println("获取token（应该只返回健康的tokens）:")
+	for i := 0; i < 6; i++ {
+		token, err := balancer.GetToken()
+		if err != nil {
+			log.Printf("错误: %v", err)
+			continue
+		}
+		fmt.Printf("  第%d次: %s\n", i+1, token)
+	}
+
+	// 恢复token健康状态
+	fmt.Println("恢复 JWT_UNHEALTHY_3 为健康...")
+	balancer.MarkTokenHealthy("JWT_UNHEALTHY_3")
+
+	fmt.Printf("恢复后状态: %d/%d tokens健康\n",
+		balancer.GetHealthyTokenCount(), balancer.GetTotalTokenCount())
+}
+
+func demoConcurrent() {
+	tokens := []string{"JWT_CONCURRENT_1", "JWT_CONCURRENT_2", "JWT_CONCURRENT_3", "JWT_CONCURRENT_4"}
+	balancer := balancer.NewJWTBalancer(tokens, config.RoundRobin)
+
+	fmt.Printf("使用 %d 个JWT tokens进行并发测试\n", len(tokens))
+
+	var wg sync.WaitGroup
+	numGoroutines := 5
+	requestsPerGoroutine := 10
+
+	tokenCounts := make(map[string]int)
+	var mutex sync.Mutex
+
+	startTime := time.Now()
+
+	for i := 0; i < numGoroutines; i++ {
+		wg.Add(1)
+		go func(goroutineID int) {
+			defer wg.Done()
+
+			for j := 0; j < requestsPerGoroutine; j++ {
+				token, err := balancer.GetToken()
+				if err != nil {
+					log.Printf("Goroutine %d 错误: %v", goroutineID, err)
+					continue
+				}
+
+				mutex.Lock()
+				tokenCounts[token]++
+				mutex.Unlock()
+
+				// 模拟一些处理时间
+				time.Sleep(time.Millisecond * 10)
+			}
+		}(i)
+	}
+
+	wg.Wait()
+	duration := time.Since(startTime)
+
+	fmt.Printf("并发测试完成，耗时: %v\n", duration)
+	fmt.Printf("总请求数: %d\n", numGoroutines*requestsPerGoroutine)
+	fmt.Println("Token使用分布:")
+
+	for token, count := range tokenCounts {
+		percentage := float64(count) / float64(numGoroutines*requestsPerGoroutine) * 100
+		fmt.Printf("  %s: %d次 (%.1f%%)\n", token, count, percentage)
+	}
+}
+
+// 演示配置加载
+//func demoConfigLoading() {
+//	fmt.Println("\n5. 配置加载演示:")
+//
+//	// 模拟环境变量配置
+//	fmt.Println("模拟配置加载...")
+//
+//	cfg := &config.Config{}
+//
+//	// 设置多个JWT tokens
+//	cfg.SetJetbrainsTokens("token1,token2,token3")
+//	cfg.BearerToken = "bearer_token_example"
+//	cfg.LoadBalanceStrategy = config.RoundRobin
+//
+//	fmt.Printf("JWT Tokens数量: %d\n", len(cfg.GetJetbrainsTokens()))
+//	fmt.Printf("Bearer Token: %s\n", cfg.BearerToken)
+//	fmt.Printf("负载均衡策略: %s\n", cfg.LoadBalanceStrategy)
+//	fmt.Printf("是否有JWT Tokens: %v\n", cfg.HasJetbrainsTokens())
+//
+//	fmt.Println("JWT Tokens列表:")
+//	for i, token := range cfg.GetJetbrainsTokens() {
+//		fmt.Printf("  %d: %s\n", i+1, token)
+//	}
+//}

examples/start_with_multiple_jwt.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+
+# 多JWT负载均衡启动示例脚本
+
+echo "=== JetBrains AI Proxy 多JWT负载均衡启动示例 ==="
+
+# 检查是否提供了JWT tokens
+if [ -z "$1" ]; then
+    echo "用法: $0 \"jwt_token1,jwt_token2,jwt_token3\" [bearer_token] [strategy] [port]"
+    echo ""
+    echo "参数说明:"
+    echo "  jwt_tokens    - 多个JWT tokens，用逗号分隔（必需）"
+    echo "  bearer_token  - Bearer token（可选，默认从环境变量读取）"
+    echo "  strategy      - 负载均衡策略：round_robin 或 random（可选，默认round_robin）"
+    echo "  port          - 监听端口（可选，默认8080）"
+    echo ""
+    echo "示例:"
+    echo "  $0 \"jwt1,jwt2,jwt3\""
+    echo "  $0 \"jwt1,jwt2,jwt3\" \"bearer123\" \"random\" 9090"
+    echo ""
+    echo "环境变量配置示例:"
+    echo "  export JWT_TOKENS=\"jwt1,jwt2,jwt3\""
+    echo "  export BEARER_TOKEN=\"your_bearer_token\""
+    echo "  export LOAD_BALANCE_STRATEGY=\"random\""
+    echo "  ./jetbrains-ai-proxy"
+    exit 1
+fi
+
+# 参数设置
+JWT_TOKENS="$1"
+BEARER_TOKEN="${2:-$BEARER_TOKEN}"
+STRATEGY="${3:-round_robin}"
+PORT="${4:-8080}"
+
+# 检查Bearer token
+if [ -z "$BEARER_TOKEN" ]; then
+    echo "错误: 需要提供Bearer token"
+    echo "请通过参数提供或设置环境变量 BEARER_TOKEN"
+    exit 1
+fi
+
+# 检查策略有效性
+if [ "$STRATEGY" != "round_robin" ] && [ "$STRATEGY" != "random" ]; then
+    echo "警告: 无效的负载均衡策略 '$STRATEGY'，使用默认策略 'round_robin'"
+    STRATEGY="round_robin"
+fi
+
+# 计算JWT tokens数量
+TOKEN_COUNT=$(echo "$JWT_TOKENS" | tr ',' '\n' | wc -l | tr -d ' ')
+
+echo "配置信息:"
+echo "  JWT Tokens数量: $TOKEN_COUNT"
+echo "  负载均衡策略: $STRATEGY"
+echo "  监听端口: $PORT"
+echo "  Bearer Token: ${BEARER_TOKEN:0:10}..."
+echo ""
+
+# 启动服务
+echo "启动 JetBrains AI Proxy..."
+echo "命令: ./jetbrains-ai-proxy -p $PORT -c \"$JWT_TOKENS\" -k \"$BEARER_TOKEN\" -s \"$STRATEGY\""
+echo ""
+
+# 检查可执行文件是否存在
+if [ ! -f "./jetbrains-ai-proxy" ]; then
+    echo "错误: 找不到可执行文件 './jetbrains-ai-proxy'"
+    echo "请先编译项目: go build -o jetbrains-ai-proxy"
+    exit 1
+fi
+
+# 启动服务
+exec ./jetbrains-ai-proxy -p "$PORT" -c "$JWT_TOKENS" -k "$BEARER_TOKEN" -s "$STRATEGY"

go.mod

@@ -0,0 +1,33 @@
+module jetbrains-ai-proxy
+
+go 1.24
+
+require (
+	github.com/bytedance/sonic v1.13.3 // indirect
+	github.com/bytedance/sonic/loader v0.2.4 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cloudwego/base64x v0.1.5 // indirect
+	github.com/dgrijalva/jwt-go v3.2.0+incompatible // indirect
+	github.com/dlclark/regexp2 v1.10.0 // indirect
+	github.com/go-resty/resty/v2 v2.16.5 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/joho/godotenv v1.5.1 // indirect
+	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
+	github.com/labstack/echo v3.3.10+incompatible // indirect
+	github.com/labstack/echo/v4 v4.13.4 // indirect
+	github.com/labstack/gommon v0.4.2 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/pkoukk/tiktoken-go v0.1.7 // indirect
+	github.com/samber/lo v1.51.0 // indirect
+	github.com/sashabaranov/go-openai v1.40.3 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.2 // indirect
+	golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect
+	golang.org/x/crypto v0.39.0 // indirect
+	golang.org/x/net v0.41.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/text v0.26.0 // indirect
+	golang.org/x/time v0.11.0 // indirect
+)

go.sum

@@ -0,0 +1,77 @@
+github.com/bytedance/sonic v1.13.3 h1:MS8gmaH16Gtirygw7jV91pDCN33NyMrPbN7qiYhEsF0=
+github.com/bytedance/sonic v1.13.3/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/bytedance/sonic/loader v0.2.4 h1:ZWCw4stuXUsn1/+zQDqeE7JKP+QO47tz7QCNan80NzY=
+github.com/bytedance/sonic/loader v0.2.4/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cloudwego/base64x v0.1.5 h1:XPciSp1xaq2VCSt6lF0phncD4koWyULpl5bUxbfCyP4=
+github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+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/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0=
+github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/go-resty/resty/v2 v2.16.5 h1:hBKqmWrr7uRc3euHVqmh1HTHcKn99Smr7o5spptdhTM=
+github.com/go-resty/resty/v2 v2.16.5/go.mod h1:hkJtXbA2iKHzJheXYvQ8snQES5ZLGKMwQ07xAwp/fiA=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/labstack/echo v3.3.10+incompatible h1:pGRcYk231ExFAyoAjAfD85kQzRJCRI8bbnE7CX5OEgg=
+github.com/labstack/echo v3.3.10+incompatible/go.mod h1:0INS7j/VjnFxD4E2wkz67b8cVwCLbBmJyDaka6Cmk1s=
+github.com/labstack/echo/v4 v4.13.4 h1:oTZZW+T3s9gAu5L8vmzihV7/lkXGZuITzTQkTEhcXEA=
+github.com/labstack/echo/v4 v4.13.4/go.mod h1:g63b33BZ5vZzcIUF8AtRH40DrTlXnx4UMC8rBdndmjQ=
+github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
+github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+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/pkoukk/tiktoken-go v0.1.7 h1:qOBHXX4PHtvIvmOtyg1EeKlwFRiMKAcoMp4Q+bLQDmw=
+github.com/pkoukk/tiktoken-go v0.1.7/go.mod h1:9NiV+i9mJKGj1rYOT+njbv+ZwA/zJxYdewGl6qVatpg=
+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/samber/lo v1.51.0 h1:kysRYLbHy/MB7kQZf5DSN50JHmMsNEdeY24VzJFu7wI=
+github.com/samber/lo v1.51.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0=
+github.com/sashabaranov/go-openai v1.40.3 h1:PkOw0SK34wrvYVOuXF1HZzuTBRh992qRZHil4kG3eYE=
+github.com/sashabaranov/go-openai v1.40.3/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
+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/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.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.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/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VAiXCnxFY6NyDX0bHDmkU=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+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/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
+golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
+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/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0=
+golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
+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=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=

internal/apiserver/router.go

@@ -0,0 +1,83 @@
+package apiserver
+
+import (
+	"fmt"
+	"github.com/labstack/echo"
+	"jetbrains-ai-proxy/internal/jetbrains"
+	"jetbrains-ai-proxy/internal/middleware"
+	"jetbrains-ai-proxy/internal/types"
+	"jetbrains-ai-proxy/internal/utils"
+	"net/http"
+
+	"github.com/sashabaranov/go-openai"
+)
+
+func RegisterRoutes(e *echo.Echo) {
+	e.Use(middleware.BearerAuth())
+	e.POST("/v1/chat/completions", handleChatCompletion)
+	e.GET("/v1/models", handleListModels)
+}
+
+func handleChatCompletion(c echo.Context) error {
+	var req openai.ChatCompletionRequest
+
+	if err := c.Bind(&req); err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error": "Invalid request payload",
+		})
+	}
+
+	_, err := types.GetModelByName(req.Model)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error": fmt.Sprintf("Model '%s' not supported", req.Model),
+		})
+	}
+
+	if len(req.Messages) == 0 {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error": "No messages found",
+		})
+	}
+
+	jetbrainsReq, err := types.ChatGPTToJetbrainsAI(req)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error": err.Error(),
+		})
+	}
+
+	stream, err := jetbrains.SendJetbrainsRequest(c.Request().Context(), jetbrainsReq)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error": err.Error(),
+		})
+	}
+	defer stream.RawBody().Close()
+
+	// 根据请求的 stream 参数决定使用哪种处理方式
+	fingerprint := utils.RandStringUsingMathRand(10)
+	if req.Stream {
+		// 流式处理
+		c.Response().Header().Set(echo.HeaderContentType, "text/event-stream")
+		c.Response().Header().Set("Cache-Control", "no-cache")
+		c.Response().Header().Set("Transfer-Encoding", "chunked")
+		c.Response().WriteHeader(http.StatusOK)
+
+		return jetbrains.StreamJetbrainsAISSEToClient(c.Request().Context(), req, c.Response().Writer, stream.RawBody(), fingerprint)
+	} else {
+		// 非流式处理
+		response, err := jetbrains.ResponseJetbrainsAIToClient(c.Request().Context(), req, stream.RawBody(), fingerprint)
+		if err != nil {
+			return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+				"error": err.Error(),
+			})
+		}
+		return c.JSON(http.StatusOK, response)
+	}
+}
+
+func handleListModels(c echo.Context) error {
+	models := types.GetSupportedModels()
+	return c.JSON(http.StatusOK, models)
+}

internal/balancer/health_checker.go

@@ -0,0 +1,216 @@
+package balancer
+
+import (
+	"context"
+	"github.com/go-resty/resty/v2"
+	"jetbrains-ai-proxy/internal/types"
+	"log"
+	"sync"
+	"time"
+)
+
+// HealthChecker JWT健康检查器
+type HealthChecker struct {
+	balancer      JWTBalancer
+	client        *resty.Client
+	checkInterval time.Duration
+	timeout       time.Duration
+	maxRetries    int
+	stopChan      chan struct{}
+	wg            sync.WaitGroup
+	running       bool
+	mutex         sync.RWMutex
+}
+
+// NewHealthChecker 创建健康检查器
+func NewHealthChecker(balancer JWTBalancer) *HealthChecker {
+	client := resty.New().
+		SetTimeout(10 * time.Second).
+		SetHeaders(map[string]string{
+			"Content-Type": "application/json",
+		})
+
+	return &HealthChecker{
+		balancer:      balancer,
+		client:        client,
+		checkInterval: 30 * time.Second, // 每30秒检查一次
+		timeout:       10 * time.Second,
+		maxRetries:    3,
+		stopChan:      make(chan struct{}),
+	}
+}
+
+// Start 启动健康检查
+func (hc *HealthChecker) Start() {
+	hc.mutex.Lock()
+	defer hc.mutex.Unlock()
+
+	if hc.running {
+		return
+	}
+
+	hc.running = true
+	hc.wg.Add(1)
+
+	go hc.healthCheckLoop()
+	log.Println("JWT health checker started")
+}
+
+// Stop 停止健康检查
+func (hc *HealthChecker) Stop() {
+	hc.mutex.Lock()
+	defer hc.mutex.Unlock()
+
+	if !hc.running {
+		return
+	}
+
+	hc.running = false
+	close(hc.stopChan)
+	hc.wg.Wait()
+	log.Println("JWT health checker stopped")
+}
+
+// healthCheckLoop 健康检查循环
+func (hc *HealthChecker) healthCheckLoop() {
+	defer hc.wg.Done()
+
+	ticker := time.NewTicker(hc.checkInterval)
+	defer ticker.Stop()
+
+	// 启动时立即执行一次检查
+	hc.performHealthCheck()
+
+	for {
+		select {
+		case <-ticker.C:
+			hc.performHealthCheck()
+		case <-hc.stopChan:
+			return
+		}
+	}
+}
+
+// performHealthCheck 执行健康检查
+func (hc *HealthChecker) performHealthCheck() {
+	log.Println("Performing JWT health check...")
+
+	// 获取所有tokens进行检查
+	baseBalancer, ok := hc.balancer.(*BaseBalancer)
+	if !ok {
+		log.Println("Warning: Cannot access tokens for health check")
+		return
+	}
+
+	baseBalancer.mutex.RLock()
+	tokens := make([]string, 0, len(baseBalancer.tokens))
+	for token := range baseBalancer.tokens {
+		tokens = append(tokens, token)
+	}
+	baseBalancer.mutex.RUnlock()
+
+	// 并发检查所有tokens
+	var wg sync.WaitGroup
+	for _, token := range tokens {
+		wg.Add(1)
+		go func(t string) {
+			defer wg.Done()
+			hc.checkTokenHealth(t)
+		}(token)
+	}
+	wg.Wait()
+
+	healthyCount := hc.balancer.GetHealthyTokenCount()
+	totalCount := hc.balancer.GetTotalTokenCount()
+	log.Printf("Health check completed: %d/%d tokens healthy", healthyCount, totalCount)
+}
+
+// checkTokenHealth 检查单个token的健康状态
+func (hc *HealthChecker) checkTokenHealth(token string) {
+	ctx, cancel := context.WithTimeout(context.Background(), hc.timeout)
+	defer cancel()
+
+	// 创建一个简单的测试请求
+	testRequest := &types.JetbrainsRequest{
+		Prompt:  types.PROMPT,
+		Profile: "openai-gpt-4o", // 使用一个通用的profile进行测试
+		Chat: types.ChatField{
+			MessageField: []types.MessageField{
+				{
+					Type:    "user_message",
+					Content: "test", // 简单的测试消息
+				},
+			},
+		},
+	}
+
+	success := false
+	for retry := 0; retry < hc.maxRetries; retry++ {
+		if hc.testTokenRequest(ctx, token, testRequest) {
+			success = true
+			break
+		}
+
+		// 重试前等待一小段时间
+		if retry < hc.maxRetries-1 {
+			time.Sleep(time.Second)
+		}
+	}
+
+	if success {
+		hc.balancer.MarkTokenHealthy(token)
+	} else {
+		hc.balancer.MarkTokenUnhealthy(token)
+		log.Printf("JWT token health check failed: %s...", token[:min(len(token), 10)])
+	}
+}
+
+// testTokenRequest 测试token请求
+func (hc *HealthChecker) testTokenRequest(ctx context.Context, token string, req *types.JetbrainsRequest) bool {
+	resp, err := hc.client.R().
+		SetContext(ctx).
+		SetHeader(types.JwtTokenKey, token).
+		SetBody(req).
+		Post(types.ChatStreamV7)
+
+	if err != nil {
+		log.Printf("Health check request error for token %s...: %v", token[:min(len(token), 10)], err)
+		return false
+	}
+
+	// 检查响应状态码
+	if resp.StatusCode() == 200 {
+		return true
+	}
+
+	// 401表示token无效，403可能表示配额用完但token有效
+	if resp.StatusCode() == 403 {
+		// 配额用完但token有效，仍然标记为健康
+		return true
+	}
+
+	log.Printf("Health check failed for token %s...: status %d",
+		token[:min(len(token), 10)], resp.StatusCode())
+	return false
+}
+
+// SetCheckInterval 设置检查间隔
+func (hc *HealthChecker) SetCheckInterval(interval time.Duration) {
+	hc.mutex.Lock()
+	defer hc.mutex.Unlock()
+	hc.checkInterval = interval
+}
+
+// SetTimeout 设置请求超时
+func (hc *HealthChecker) SetTimeout(timeout time.Duration) {
+	hc.mutex.Lock()
+	defer hc.mutex.Unlock()
+	hc.timeout = timeout
+}
+
+// SetMaxRetries 设置最大重试次数
+func (hc *HealthChecker) SetMaxRetries(retries int) {
+	hc.mutex.Lock()
+	defer hc.mutex.Unlock()
+	hc.maxRetries = retries
+}

internal/balancer/jwt_balancer.go

@@ -0,0 +1,175 @@
+package balancer
+
+import (
+	"fmt"
+	"jetbrains-ai-proxy/internal/config"
+	"math/rand"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// JWTBalancer JWT负载均衡器接口
+type JWTBalancer interface {
+	GetToken() (string, error)
+	MarkTokenUnhealthy(token string)
+	MarkTokenHealthy(token string)
+	GetHealthyTokenCount() int
+	GetTotalTokenCount() int
+	RefreshTokens(tokens []string)
+}
+
+// TokenStatus token状态
+type TokenStatus struct {
+	Token     string
+	Healthy   bool
+	LastUsed  time.Time
+	ErrorCount int64
+}
+
+// BaseBalancer 基础负载均衡器
+type BaseBalancer struct {
+	tokens   map[string]*TokenStatus
+	strategy config.LoadBalanceStrategy
+	mutex    sync.RWMutex
+	counter  int64 // 用于轮询计数
+	rand     *rand.Rand
+}
+
+// NewJWTBalancer 创建JWT负载均衡器
+func NewJWTBalancer(tokens []string, strategy config.LoadBalanceStrategy) JWTBalancer {
+	balancer := &BaseBalancer{
+		tokens:   make(map[string]*TokenStatus),
+		strategy: strategy,
+		rand:     rand.New(rand.NewSource(time.Now().UnixNano())),
+	}
+	
+	// 初始化tokens
+	for _, token := range tokens {
+		balancer.tokens[token] = &TokenStatus{
+			Token:     token,
+			Healthy:   true,
+			LastUsed:  time.Now(),
+			ErrorCount: 0,
+		}
+	}
+	
+	return balancer
+}
+
+// GetToken 获取一个可用的token
+func (b *BaseBalancer) GetToken() (string, error) {
+	b.mutex.RLock()
+	defer b.mutex.RUnlock()
+	
+	// 获取所有健康的tokens
+	healthyTokens := make([]*TokenStatus, 0)
+	for _, status := range b.tokens {
+		if status.Healthy {
+			healthyTokens = append(healthyTokens, status)
+		}
+	}
+	
+	if len(healthyTokens) == 0 {
+		return "", fmt.Errorf("no healthy JWT tokens available")
+	}
+	
+	var selectedToken *TokenStatus
+	
+	switch b.strategy {
+	case config.RoundRobin:
+		// 轮询策略
+		index := atomic.AddInt64(&b.counter, 1) % int64(len(healthyTokens))
+		selectedToken = healthyTokens[index]
+	case config.Random:
+		// 随机策略
+		index := b.rand.Intn(len(healthyTokens))
+		selectedToken = healthyTokens[index]
+	default:
+		// 默认使用轮询
+		index := atomic.AddInt64(&b.counter, 1) % int64(len(healthyTokens))
+		selectedToken = healthyTokens[index]
+	}
+	
+	// 更新最后使用时间
+	selectedToken.LastUsed = time.Now()
+	
+	return selectedToken.Token, nil
+}
+
+// MarkTokenUnhealthy 标记token为不健康
+func (b *BaseBalancer) MarkTokenUnhealthy(token string) {
+	b.mutex.Lock()
+	defer b.mutex.Unlock()
+	
+	if status, exists := b.tokens[token]; exists {
+		status.Healthy = false
+		atomic.AddInt64(&status.ErrorCount, 1)
+		fmt.Printf("JWT token marked as unhealthy: %s (errors: %d)\n", 
+			token[:min(len(token), 10)]+"...", status.ErrorCount)
+	}
+}
+
+// MarkTokenHealthy 标记token为健康
+func (b *BaseBalancer) MarkTokenHealthy(token string) {
+	b.mutex.Lock()
+	defer b.mutex.Unlock()
+	
+	if status, exists := b.tokens[token]; exists {
+		status.Healthy = true
+		atomic.StoreInt64(&status.ErrorCount, 0)
+		fmt.Printf("JWT token marked as healthy: %s\n", 
+			token[:min(len(token), 10)]+"...")
+	}
+}
+
+// GetHealthyTokenCount 获取健康token数量
+func (b *BaseBalancer) GetHealthyTokenCount() int {
+	b.mutex.RLock()
+	defer b.mutex.RUnlock()
+	
+	count := 0
+	for _, status := range b.tokens {
+		if status.Healthy {
+			count++
+		}
+	}
+	return count
+}
+
+// GetTotalTokenCount 获取总token数量
+func (b *BaseBalancer) GetTotalTokenCount() int {
+	b.mutex.RLock()
+	defer b.mutex.RUnlock()
+	
+	return len(b.tokens)
+}
+
+// RefreshTokens 刷新token列表
+func (b *BaseBalancer) RefreshTokens(tokens []string) {
+	b.mutex.Lock()
+	defer b.mutex.Unlock()
+	
+	// 清空现有tokens
+	b.tokens = make(map[string]*TokenStatus)
+	
+	// 添加新tokens
+	for _, token := range tokens {
+		b.tokens[token] = &TokenStatus{
+			Token:     token,
+			Healthy:   true,
+			LastUsed:  time.Now(),
+			ErrorCount: 0,
+		}
+	}
+	
+	fmt.Printf("JWT tokens refreshed, total: %d\n", len(tokens))
+}
+
+// min 辅助函数
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

internal/balancer/jwt_balancer_test.go

@@ -0,0 +1,226 @@
+package balancer
+
+import (
+	"jetbrains-ai-proxy/internal/config"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestNewJWTBalancer(t *testing.T) {
+	tokens := []string{"token1", "token2", "token3"}
+	
+	// 测试轮询策略
+	balancer := NewJWTBalancer(tokens, config.RoundRobin)
+	if balancer == nil {
+		t.Fatal("Expected balancer to be created")
+	}
+	
+	if balancer.GetTotalTokenCount() != 3 {
+		t.Errorf("Expected 3 tokens, got %d", balancer.GetTotalTokenCount())
+	}
+	
+	if balancer.GetHealthyTokenCount() != 3 {
+		t.Errorf("Expected 3 healthy tokens, got %d", balancer.GetHealthyTokenCount())
+	}
+}
+
+func TestRoundRobinStrategy(t *testing.T) {
+	tokens := []string{"token1", "token2", "token3"}
+	balancer := NewJWTBalancer(tokens, config.RoundRobin)
+	
+	// 测试轮询顺序
+	expectedOrder := []string{"token1", "token2", "token3", "token1", "token2", "token3"}
+	
+	for i, expected := range expectedOrder {
+		token, err := balancer.GetToken()
+		if err != nil {
+			t.Fatalf("Unexpected error at iteration %d: %v", i, err)
+		}
+		
+		if token != expected {
+			t.Errorf("At iteration %d, expected %s, got %s", i, expected, token)
+		}
+	}
+}
+
+func TestRandomStrategy(t *testing.T) {
+	tokens := []string{"token1", "token2", "token3"}
+	balancer := NewJWTBalancer(tokens, config.Random)
+	
+	// 测试随机策略 - 多次获取token，确保都是有效的
+	tokenCounts := make(map[string]int)
+	iterations := 100
+	
+	for i := 0; i < iterations; i++ {
+		token, err := balancer.GetToken()
+		if err != nil {
+			t.Fatalf("Unexpected error at iteration %d: %v", i, err)
+		}
+		
+		// 检查token是否在预期列表中
+		found := false
+		for _, expectedToken := range tokens {
+			if token == expectedToken {
+				found = true
+				break
+			}
+		}
+		
+		if !found {
+			t.Errorf("Got unexpected token: %s", token)
+		}
+		
+		tokenCounts[token]++
+	}
+	
+	// 确保所有token都被使用过（随机策略下应该都有机会被选中）
+	for _, token := range tokens {
+		if tokenCounts[token] == 0 {
+			t.Errorf("Token %s was never selected", token)
+		}
+	}
+}
+
+func TestMarkTokenUnhealthy(t *testing.T) {
+	tokens := []string{"token1", "token2", "token3"}
+	balancer := NewJWTBalancer(tokens, config.RoundRobin)
+	
+	// 标记一个token为不健康
+	balancer.MarkTokenUnhealthy("token2")
+	
+	if balancer.GetHealthyTokenCount() != 2 {
+		t.Errorf("Expected 2 healthy tokens, got %d", balancer.GetHealthyTokenCount())
+	}
+	
+	// 获取token，应该只返回健康的token
+	for i := 0; i < 10; i++ {
+		token, err := balancer.GetToken()
+		if err != nil {
+			t.Fatalf("Unexpected error: %v", err)
+		}
+		
+		if token == "token2" {
+			t.Errorf("Got unhealthy token: %s", token)
+		}
+	}
+}
+
+func TestMarkTokenHealthy(t *testing.T) {
+	tokens := []string{"token1", "token2", "token3"}
+	balancer := NewJWTBalancer(tokens, config.RoundRobin)
+	
+	// 先标记为不健康，再标记为健康
+	balancer.MarkTokenUnhealthy("token2")
+	if balancer.GetHealthyTokenCount() != 2 {
+		t.Errorf("Expected 2 healthy tokens after marking unhealthy, got %d", balancer.GetHealthyTokenCount())
+	}
+	
+	balancer.MarkTokenHealthy("token2")
+	if balancer.GetHealthyTokenCount() != 3 {
+		t.Errorf("Expected 3 healthy tokens after marking healthy, got %d", balancer.GetHealthyTokenCount())
+	}
+}
+
+func TestNoHealthyTokens(t *testing.T) {
+	tokens := []string{"token1", "token2"}
+	balancer := NewJWTBalancer(tokens, config.RoundRobin)
+	
+	// 标记所有token为不健康
+	balancer.MarkTokenUnhealthy("token1")
+	balancer.MarkTokenUnhealthy("token2")
+	
+	// 尝试获取token应该返回错误
+	_, err := balancer.GetToken()
+	if err == nil {
+		t.Error("Expected error when no healthy tokens available")
+	}
+}
+
+func TestConcurrentAccess(t *testing.T) {
+	tokens := []string{"token1", "token2", "token3", "token4", "token5"}
+	balancer := NewJWTBalancer(tokens, config.RoundRobin)
+	
+	var wg sync.WaitGroup
+	numGoroutines := 10
+	tokensPerGoroutine := 100
+	
+	// 并发获取tokens
+	for i := 0; i < numGoroutines; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < tokensPerGoroutine; j++ {
+				_, err := balancer.GetToken()
+				if err != nil {
+					t.Errorf("Unexpected error in concurrent access: %v", err)
+				}
+			}
+		}()
+	}
+	
+	// 并发标记tokens健康状态
+	for i := 0; i < numGoroutines; i++ {
+		wg.Add(1)
+		go func(index int) {
+			defer wg.Done()
+			token := tokens[index%len(tokens)]
+			for j := 0; j < 10; j++ {
+				if j%2 == 0 {
+					balancer.MarkTokenUnhealthy(token)
+				} else {
+					balancer.MarkTokenHealthy(token)
+				}
+				time.Sleep(time.Millisecond)
+			}
+		}(i)
+	}
+	
+	wg.Wait()
+	
+	// 确保最终状态正常
+	if balancer.GetTotalTokenCount() != len(tokens) {
+		t.Errorf("Expected %d total tokens, got %d", len(tokens), balancer.GetTotalTokenCount())
+	}
+}
+
+func TestRefreshTokens(t *testing.T) {
+	tokens := []string{"token1", "token2"}
+	balancer := NewJWTBalancer(tokens, config.RoundRobin)
+	
+	if balancer.GetTotalTokenCount() != 2 {
+		t.Errorf("Expected 2 tokens initially, got %d", balancer.GetTotalTokenCount())
+	}
+	
+	// 刷新tokens
+	newTokens := []string{"token3", "token4", "token5"}
+	balancer.RefreshTokens(newTokens)
+	
+	if balancer.GetTotalTokenCount() != 3 {
+		t.Errorf("Expected 3 tokens after refresh, got %d", balancer.GetTotalTokenCount())
+	}
+	
+	if balancer.GetHealthyTokenCount() != 3 {
+		t.Errorf("Expected 3 healthy tokens after refresh, got %d", balancer.GetHealthyTokenCount())
+	}
+	
+	// 验证新tokens可以被获取
+	for i := 0; i < 6; i++ { // 两轮完整轮询
+		token, err := balancer.GetToken()
+		if err != nil {
+			t.Fatalf("Unexpected error: %v", err)
+		}
+		
+		found := false
+		for _, newToken := range newTokens {
+			if token == newToken {
+				found = true
+				break
+			}
+		}
+		
+		if !found {
+			t.Errorf("Got unexpected token after refresh: %s", token)
+		}
+	}
+}

internal/config/config.go

@@ -0,0 +1,430 @@
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/joho/godotenv"
+)
+
+var (
+	GlobalConfig *Manager
+	once         sync.Once
+)
+
+// LoadBalanceStrategy 负载均衡策略
+type LoadBalanceStrategy string
+
+const (
+	RoundRobin LoadBalanceStrategy = "round_robin"
+	Random     LoadBalanceStrategy = "random"
+)
+
+// JWTTokenConfig JWT token配置
+type JWTTokenConfig struct {
+	Token       string            `json:"token"`
+	Name        string            `json:"name,omitempty"`
+	Description string            `json:"description,omitempty"`
+	Priority    int               `json:"priority,omitempty"`
+	Metadata    map[string]string `json:"metadata,omitempty"`
+}
+
+// Config 应用配置
+type Config struct {
+	JetbrainsTokens     []JWTTokenConfig    `json:"jetbrains_tokens"`
+	BearerToken         string              `json:"bearer_token"`
+	LoadBalanceStrategy LoadBalanceStrategy `json:"load_balance_strategy"`
+	HealthCheckInterval time.Duration       `json:"health_check_interval"`
+	ServerPort          int                 `json:"server_port"`
+	ServerHost          string              `json:"server_host"`
+}
+
+// Manager 配置管理器
+type Manager struct {
+	config     *Config
+	configPath string
+	mutex      sync.RWMutex
+}
+
+// GetGlobalConfig 获取全局配置管理器（单例）
+func GetGlobalConfig() *Manager {
+	once.Do(func() {
+		GlobalConfig = NewManager()
+	})
+	return GlobalConfig
+}
+
+// NewManager 创建新的配置管理器
+func NewManager() *Manager {
+	return &Manager{
+		config: &Config{
+			LoadBalanceStrategy: RoundRobin,
+			HealthCheckInterval: 30 * time.Second,
+			ServerPort:          8080,
+			ServerHost:          "0.0.0.0",
+		},
+	}
+}
+
+// LoadConfig 加载配置
+func (m *Manager) LoadConfig() error {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	// 1. 首先尝试加载 .env 文件
+	_ = godotenv.Load()
+
+	// 2. 自动发现并加载配置文件
+	if err := m.loadConfigFile(); err != nil {
+		log.Printf("Warning: Failed to load config file: %v", err)
+	}
+
+	// 3. 从环境变量加载配置
+	m.loadFromEnv()
+
+	// 4. 验证配置
+	return m.validateConfig()
+}
+
+// loadConfigFile 自动发现并加载配置文件
+func (m *Manager) loadConfigFile() error {
+	// 配置文件搜索路径
+	searchPaths := []string{
+		"config.json",
+		"config/config.json",
+		"configs/config.json",
+		".config/jetbrains-ai-proxy.json",
+		os.ExpandEnv("$HOME/.config/jetbrains-ai-proxy/config.json"),
+	}
+
+	for _, path := range searchPaths {
+		if _, err := os.Stat(path); err == nil {
+			log.Printf("Found config file: %s", path)
+			return m.loadFromFile(path)
+		}
+	}
+
+	return fmt.Errorf("no config file found in search paths")
+}
+
+// loadFromFile 从文件加载配置
+func (m *Manager) loadFromFile(path string) error {
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("failed to read config file %s: %v", path, err)
+	}
+
+	var fileConfig Config
+	if err := json.Unmarshal(data, &fileConfig); err != nil {
+		return fmt.Errorf("failed to parse config file %s: %v", path, err)
+	}
+
+	// 合并配置
+	m.mergeConfig(&fileConfig)
+	m.configPath = path
+	log.Printf("Loaded config from file: %s", path)
+	return nil
+}
+
+// loadFromEnv 从环境变量加载配置
+func (m *Manager) loadFromEnv() {
+	// JWT Tokens
+	jwtTokensStr := os.Getenv("JWT_TOKENS")
+	if jwtTokensStr == "" {
+		// 兼容旧的单token配置
+		jwtTokensStr = os.Getenv("JWT_TOKEN")
+	}
+
+	if jwtTokensStr != "" {
+		tokens := m.parseJWTTokens(jwtTokensStr)
+		if len(tokens) > 0 {
+			m.config.JetbrainsTokens = tokens
+		}
+	}
+
+	// Bearer Token
+	if bearerToken := os.Getenv("BEARER_TOKEN"); bearerToken != "" {
+		m.config.BearerToken = bearerToken
+	}
+
+	// Load Balance Strategy
+	if strategy := os.Getenv("LOAD_BALANCE_STRATEGY"); strategy != "" {
+		if strategy == string(RoundRobin) || strategy == string(Random) {
+			m.config.LoadBalanceStrategy = LoadBalanceStrategy(strategy)
+		}
+	}
+
+	// Server configuration
+	if port := os.Getenv("SERVER_PORT"); port != "" {
+		if p, err := parsePort(port); err == nil {
+			m.config.ServerPort = p
+		}
+	}
+
+	if host := os.Getenv("SERVER_HOST"); host != "" {
+		m.config.ServerHost = host
+	}
+}
+
+// parseJWTTokens 解析JWT tokens字符串
+func (m *Manager) parseJWTTokens(tokensStr string) []JWTTokenConfig {
+	var tokens []JWTTokenConfig
+	tokenList := strings.Split(tokensStr, ",")
+
+	for i, token := range tokenList {
+		token = strings.TrimSpace(token)
+		if token != "" {
+			tokens = append(tokens, JWTTokenConfig{
+				Token:    token,
+				Name:     fmt.Sprintf("JWT_%d", i+1),
+				Priority: 1,
+			})
+		}
+	}
+
+	return tokens
+}
+
+// mergeConfig 合并配置
+func (m *Manager) mergeConfig(other *Config) {
+	if len(other.JetbrainsTokens) > 0 {
+		m.config.JetbrainsTokens = other.JetbrainsTokens
+	}
+	if other.BearerToken != "" {
+		m.config.BearerToken = other.BearerToken
+	}
+	if other.LoadBalanceStrategy != "" {
+		m.config.LoadBalanceStrategy = other.LoadBalanceStrategy
+	}
+	if other.HealthCheckInterval > 0 {
+		m.config.HealthCheckInterval = other.HealthCheckInterval
+	}
+	if other.ServerPort > 0 {
+		m.config.ServerPort = other.ServerPort
+	}
+	if other.ServerHost != "" {
+		m.config.ServerHost = other.ServerHost
+	}
+}
+
+// validateConfig 验证配置
+func (m *Manager) validateConfig() error {
+	if len(m.config.JetbrainsTokens) == 0 {
+		return fmt.Errorf("no JWT tokens configured")
+	}
+
+	if m.config.BearerToken == "" {
+		return fmt.Errorf("bearer token is required")
+	}
+
+	if m.config.ServerPort <= 0 || m.config.ServerPort > 65535 {
+		return fmt.Errorf("invalid server port: %d", m.config.ServerPort)
+	}
+
+	return nil
+}
+
+// GetConfig 获取当前配置
+func (m *Manager) GetConfig() *Config {
+	m.mutex.RLock()
+	defer m.mutex.RUnlock()
+
+	// 返回配置的副本
+	configCopy := *m.config
+	return &configCopy
+}
+
+// GetJWTTokens 获取JWT tokens字符串列表
+func (m *Manager) GetJWTTokens() []string {
+	m.mutex.RLock()
+	defer m.mutex.RUnlock()
+
+	tokens := make([]string, len(m.config.JetbrainsTokens))
+	for i, tokenConfig := range m.config.JetbrainsTokens {
+		tokens[i] = tokenConfig.Token
+	}
+	return tokens
+}
+
+// GetJWTTokenConfigs 获取JWT token配置列表
+func (m *Manager) GetJWTTokenConfigs() []JWTTokenConfig {
+	m.mutex.RLock()
+	defer m.mutex.RUnlock()
+
+	configs := make([]JWTTokenConfig, len(m.config.JetbrainsTokens))
+	copy(configs, m.config.JetbrainsTokens)
+	return configs
+}
+
+// SetJWTTokens 设置JWT tokens（用于命令行参数）
+func (m *Manager) SetJWTTokens(tokensStr string) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	if tokensStr != "" {
+		m.config.JetbrainsTokens = m.parseJWTTokens(tokensStr)
+	}
+}
+
+// SetBearerToken 设置Bearer token
+func (m *Manager) SetBearerToken(token string) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	m.config.BearerToken = token
+}
+
+// SetLoadBalanceStrategy 设置负载均衡策略
+func (m *Manager) SetLoadBalanceStrategy(strategy string) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	if strategy == string(RoundRobin) || strategy == string(Random) {
+		m.config.LoadBalanceStrategy = LoadBalanceStrategy(strategy)
+	}
+}
+
+// HasJWTTokens 检查是否有可用的JWT tokens
+func (m *Manager) HasJWTTokens() bool {
+	m.mutex.RLock()
+	defer m.mutex.RUnlock()
+
+	return len(m.config.JetbrainsTokens) > 0
+}
+
+// SaveConfig 保存配置到文件
+func (m *Manager) SaveConfig() error {
+	m.mutex.RLock()
+	defer m.mutex.RUnlock()
+
+	if m.configPath == "" {
+		m.configPath = "config.json"
+	}
+
+	// 确保目录存在
+	if err := os.MkdirAll(filepath.Dir(m.configPath), 0755); err != nil {
+		return fmt.Errorf("failed to create config directory: %v", err)
+	}
+
+	data, err := json.MarshalIndent(m.config, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal config: %v", err)
+	}
+
+	if err := ioutil.WriteFile(m.configPath, data, 0644); err != nil {
+		return fmt.Errorf("failed to write config file: %v", err)
+	}
+
+	log.Printf("Config saved to: %s", m.configPath)
+	return nil
+}
+
+// GenerateExampleConfig 生成示例配置文件
+func (m *Manager) GenerateExampleConfig(path string) error {
+	exampleConfig := &Config{
+		JetbrainsTokens: []JWTTokenConfig{
+			{
+				Token:       "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+				Name:        "Primary_JWT",
+				Description: "Primary JWT token for JetBrains AI",
+				Priority:    1,
+				Metadata: map[string]string{
+					"environment": "production",
+					"region":      "us-east-1",
+				},
+			},
+			{
+				Token:       "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+				Name:        "Secondary_JWT",
+				Description: "Secondary JWT token for load balancing",
+				Priority:    2,
+				Metadata: map[string]string{
+					"environment": "production",
+					"region":      "us-west-2",
+				},
+			},
+		},
+		BearerToken:         "your_bearer_token_here",
+		LoadBalanceStrategy: RoundRobin,
+		HealthCheckInterval: 30 * time.Second,
+		ServerPort:          8080,
+		ServerHost:          "0.0.0.0",
+	}
+
+	// 确保目录存在
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		return fmt.Errorf("failed to create directory: %v", err)
+	}
+
+	data, err := json.MarshalIndent(exampleConfig, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal example config: %v", err)
+	}
+
+	if err := ioutil.WriteFile(path, data, 0644); err != nil {
+		return fmt.Errorf("failed to write example config: %v", err)
+	}
+
+	log.Printf("Example config generated: %s", path)
+	return nil
+}
+
+// PrintConfig 打印当前配置信息
+func (m *Manager) PrintConfig() {
+	m.mutex.RLock()
+	defer m.mutex.RUnlock()
+
+	fmt.Println("=== Current Configuration ===")
+	fmt.Printf("JWT Tokens: %d configured\n", len(m.config.JetbrainsTokens))
+	for i, token := range m.config.JetbrainsTokens {
+		fmt.Printf("  %d. %s (%s...)\n", i+1, token.Name, token.Token[:min(len(token.Token), 20)])
+	}
+	fmt.Printf("Bearer Token: %s...\n", m.config.BearerToken[:min(len(m.config.BearerToken), 20)])
+	fmt.Printf("Load Balance Strategy: %s\n", m.config.LoadBalanceStrategy)
+	fmt.Printf("Health Check Interval: %v\n", m.config.HealthCheckInterval)
+	fmt.Printf("Server: %s:%d\n", m.config.ServerHost, m.config.ServerPort)
+	if m.configPath != "" {
+		fmt.Printf("Config File: %s\n", m.configPath)
+	}
+	fmt.Println("=============================")
+}
+
+// 辅助函数
+func parsePort(portStr string) (int, error) {
+	var port int
+	if _, err := fmt.Sscanf(portStr, "%d", &port); err != nil {
+		return 0, err
+	}
+	if port <= 0 || port > 65535 {
+		return 0, fmt.Errorf("invalid port: %d", port)
+	}
+	return port, nil
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// 向后兼容的全局变量和函数
+var JetbrainsAiConfig *Config
+
+// LoadConfig 向后兼容的配置加载函数
+func LoadConfig() *Config {
+	manager := GetGlobalConfig()
+	if err := manager.LoadConfig(); err != nil {
+		log.Printf("Warning: %v", err)
+	}
+
+	JetbrainsAiConfig = manager.GetConfig()
+	return JetbrainsAiConfig
+}

internal/config/discovery.go

@@ -0,0 +1,293 @@
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+// ConfigDiscovery 配置发现器
+type ConfigDiscovery struct {
+	searchPaths []string
+	manager     *Manager
+}
+
+// NewConfigDiscovery 创建配置发现器
+func NewConfigDiscovery(manager *Manager) *ConfigDiscovery {
+	return &ConfigDiscovery{
+		manager: manager,
+		searchPaths: []string{
+			// 当前目录
+			"config.json",
+			"jetbrains-ai-proxy.json",
+			".jetbrains-ai-proxy.json",
+
+			// config 目录
+			"config/config.json",
+			"config/jetbrains-ai-proxy.json",
+			"configs/config.json",
+			"configs/jetbrains-ai-proxy.json",
+
+			// 隐藏配置目录
+			".config/config.json",
+			".config/jetbrains-ai-proxy.json",
+
+			// 用户主目录
+			os.ExpandEnv("$HOME/.config/jetbrains-ai-proxy/config.json"),
+			os.ExpandEnv("$HOME/.jetbrains-ai-proxy/config.json"),
+			os.ExpandEnv("$HOME/.jetbrains-ai-proxy.json"),
+
+			// 系统配置目录 (Linux/macOS)
+			"/etc/jetbrains-ai-proxy/config.json",
+			"/usr/local/etc/jetbrains-ai-proxy/config.json",
+		},
+	}
+}
+
+// DiscoverAndLoad 发现并加载配置文件
+func (cd *ConfigDiscovery) DiscoverAndLoad() error {
+	log.Println("Starting configuration discovery...")
+
+	// 1. 尝试从环境变量指定的配置文件加载
+	if configPath := os.Getenv("CONFIG_FILE"); configPath != "" {
+		if err := cd.loadConfigFile(configPath); err != nil {
+			log.Printf("Failed to load config from CONFIG_FILE=%s: %v", configPath, err)
+		} else {
+			log.Printf("Successfully loaded config from CONFIG_FILE: %s", configPath)
+			return nil
+		}
+	}
+
+	// 2. 搜索预定义路径
+	for _, path := range cd.searchPaths {
+		if cd.fileExists(path) {
+			if err := cd.loadConfigFile(path); err != nil {
+				log.Printf("Failed to load config from %s: %v", path, err)
+				continue
+			}
+			log.Printf("Successfully loaded config from: %s", path)
+			return nil
+		}
+	}
+
+	// 3. 尝试从当前目录的 .env 文件加载
+	if cd.fileExists(".env") {
+		log.Println("Found .env file, loading environment variables...")
+		return nil // .env 文件会在 LoadConfig 中自动加载
+	}
+
+	// 4. 如果没有找到配置文件，生成示例配置
+	log.Println("No configuration file found, generating example config...")
+	return cd.generateDefaultConfig()
+}
+
+// loadConfigFile 加载指定的配置文件
+func (cd *ConfigDiscovery) loadConfigFile(path string) error {
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("failed to read config file: %v", err)
+	}
+
+	var config Config
+	if err := json.Unmarshal(data, &config); err != nil {
+		return fmt.Errorf("failed to parse config file: %v", err)
+	}
+
+	// 验证配置
+	if err := cd.validateLoadedConfig(&config); err != nil {
+		return fmt.Errorf("invalid config: %v", err)
+	}
+
+	// 合并到管理器
+	cd.manager.mutex.Lock()
+	cd.manager.mergeConfig(&config)
+	cd.manager.configPath = path
+	cd.manager.mutex.Unlock()
+
+	return nil
+}
+
+// validateLoadedConfig 验证加载的配置
+func (cd *ConfigDiscovery) validateLoadedConfig(config *Config) error {
+	if len(config.JetbrainsTokens) == 0 {
+		return fmt.Errorf("no JWT tokens found in config")
+	}
+
+	// 验证每个JWT token
+	for i, tokenConfig := range config.JetbrainsTokens {
+		if tokenConfig.Token == "" {
+			return fmt.Errorf("JWT token %d is empty", i+1)
+		}
+		if len(tokenConfig.Token) < 10 {
+			return fmt.Errorf("JWT token %d appears to be invalid (too short)", i+1)
+		}
+	}
+
+	if config.BearerToken == "" {
+		log.Println("Warning: No bearer token found in config file")
+	}
+
+	return nil
+}
+
+// generateDefaultConfig 生成默认配置
+func (cd *ConfigDiscovery) generateDefaultConfig() error {
+	configDir := "config"
+	configPath := filepath.Join(configDir, "config.json")
+
+	// 创建配置目录
+	if err := os.MkdirAll(configDir, 0755); err != nil {
+		return fmt.Errorf("failed to create config directory: %v", err)
+	}
+
+	// 生成示例配置
+	if err := cd.manager.GenerateExampleConfig(configPath); err != nil {
+		return fmt.Errorf("failed to generate example config: %v", err)
+	}
+
+	// 同时生成 .env 示例文件
+	envPath := ".env.example"
+	if err := cd.generateEnvExample(envPath); err != nil {
+		log.Printf("Warning: Failed to generate .env example: %v", err)
+	}
+
+	log.Printf("Generated example configuration files:")
+	log.Printf("  - %s (JSON format)", configPath)
+	log.Printf("  - %s (Environment variables)", envPath)
+	log.Printf("Please edit these files with your actual JWT tokens and restart the application.")
+
+	return fmt.Errorf("no valid configuration found, example files generated")
+}
+
+// generateEnvExample 生成 .env 示例文件
+func (cd *ConfigDiscovery) generateEnvExample(path string) error {
+	envContent := `# JetBrains AI Proxy Configuration
+# Copy this file to .env and fill in your actual values
+
+# Multiple JWT tokens (comma-separated)
+JWT_TOKENS=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...,eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...
+
+# Or single JWT token (for backward compatibility)
+# JWT_TOKEN=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...
+
+# Bearer token for API authentication
+BEARER_TOKEN=your_bearer_token_here
+
+# Load balancing strategy: round_robin or random
+LOAD_BALANCE_STRATEGY=round_robin
+
+# Server configuration
+SERVER_HOST=0.0.0.0
+SERVER_PORT=8080
+
+# Alternative: specify config file path
+# CONFIG_FILE=config/config.json
+`
+
+	return ioutil.WriteFile(path, []byte(envContent), 0644)
+}
+
+// fileExists 检查文件是否存在
+func (cd *ConfigDiscovery) fileExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// WatchConfig 监控配置文件变化（简单实现）
+func (cd *ConfigDiscovery) WatchConfig() {
+	if cd.manager.configPath == "" {
+		return
+	}
+
+	go func() {
+		var lastModTime time.Time
+
+		// 获取初始修改时间
+		if stat, err := os.Stat(cd.manager.configPath); err == nil {
+			lastModTime = stat.ModTime()
+		}
+
+		ticker := time.NewTicker(5 * time.Second)
+		defer ticker.Stop()
+
+		for range ticker.C {
+			stat, err := os.Stat(cd.manager.configPath)
+			if err != nil {
+				continue
+			}
+
+			if stat.ModTime().After(lastModTime) {
+				log.Printf("Config file changed, reloading: %s", cd.manager.configPath)
+				if err := cd.loadConfigFile(cd.manager.configPath); err != nil {
+					log.Printf("Failed to reload config: %v", err)
+				} else {
+					log.Println("Config reloaded successfully")
+				}
+				lastModTime = stat.ModTime()
+			}
+		}
+	}()
+}
+
+// ListAvailableConfigs 列出可用的配置文件
+func (cd *ConfigDiscovery) ListAvailableConfigs() []string {
+	var available []string
+
+	for _, path := range cd.searchPaths {
+		if cd.fileExists(path) {
+			available = append(available, path)
+		}
+	}
+
+	return available
+}
+
+// ValidateConfigFile 验证配置文件格式
+func (cd *ConfigDiscovery) ValidateConfigFile(path string) error {
+	if !cd.fileExists(path) {
+		return fmt.Errorf("config file does not exist: %s", path)
+	}
+
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("failed to read config file: %v", err)
+	}
+
+	var config Config
+	if err := json.Unmarshal(data, &config); err != nil {
+		return fmt.Errorf("invalid JSON format: %v", err)
+	}
+
+	return cd.validateLoadedConfig(&config)
+}
+
+// GetConfigSummary 获取配置摘要信息
+func (cd *ConfigDiscovery) GetConfigSummary() map[string]interface{} {
+	config := cd.manager.GetConfig()
+
+	// 隐藏敏感信息
+	tokenSummary := make([]map[string]interface{}, len(config.JetbrainsTokens))
+	for i, token := range config.JetbrainsTokens {
+		tokenSummary[i] = map[string]interface{}{
+			"name":          token.Name,
+			"description":   token.Description,
+			"priority":      token.Priority,
+			"token_preview": token.Token[:min(len(token.Token), 20)] + "...",
+		}
+	}
+
+	return map[string]interface{}{
+		"jwt_tokens_count":      len(config.JetbrainsTokens),
+		"jwt_tokens":            tokenSummary,
+		"bearer_token_set":      config.BearerToken != "",
+		"load_balance_strategy": config.LoadBalanceStrategy,
+		"health_check_interval": config.HealthCheckInterval.String(),
+		"server_host":           config.ServerHost,
+		"server_port":           config.ServerPort,
+		"config_file":           cd.manager.configPath,
+	}
+}

internal/jetbrains/client.go

@@ -0,0 +1,188 @@
+package jetbrains
+
+import (
+	"context"
+	"fmt"
+	"github.com/go-resty/resty/v2"
+	"jetbrains-ai-proxy/internal/balancer"
+	"jetbrains-ai-proxy/internal/config"
+	"jetbrains-ai-proxy/internal/types"
+	"jetbrains-ai-proxy/internal/utils"
+	"log"
+	"sync"
+)
+
+var (
+	jwtBalancer    balancer.JWTBalancer
+	healthChecker  *balancer.HealthChecker
+	initOnce       sync.Once
+	configManager  *config.Manager
+)
+
+// InitializeFromConfig 从配置管理器初始化JWT负载均衡器
+func InitializeFromConfig() error {
+	var initErr error
+
+	initOnce.Do(func() {
+		configManager = config.GetGlobalConfig()
+
+		// 加载配置
+		if err := configManager.LoadConfig(); err != nil {
+			initErr = fmt.Errorf("failed to load config: %v", err)
+			return
+		}
+
+		// 获取配置
+		cfg := configManager.GetConfig()
+		tokens := configManager.GetJWTTokens()
+
+		if len(tokens) == 0 {
+			initErr = fmt.Errorf("no JWT tokens configured")
+			return
+		}
+
+		// 创建负载均衡器
+		jwtBalancer = balancer.NewJWTBalancer(tokens, cfg.LoadBalanceStrategy)
+
+		// 创建并启动健康检查器
+		healthChecker = balancer.NewHealthChecker(jwtBalancer)
+		if cfg.HealthCheckInterval > 0 {
+			healthChecker.SetCheckInterval(cfg.HealthCheckInterval)
+		}
+		healthChecker.Start()
+
+		log.Printf("JWT balancer initialized from config:")
+		log.Printf("  - Tokens: %d", len(tokens))
+		log.Printf("  - Strategy: %s", cfg.LoadBalanceStrategy)
+		log.Printf("  - Health check interval: %v", cfg.HealthCheckInterval)
+	})
+
+	return initErr
+}
+
+// InitializeBalancer 初始化JWT负载均衡器（向后兼容）
+func InitializeBalancer(tokens []string, strategy string) error {
+	if len(tokens) == 0 {
+		return fmt.Errorf("no JWT tokens provided")
+	}
+
+	var balanceStrategy config.LoadBalanceStrategy
+	switch strategy {
+	case "random":
+		balanceStrategy = config.Random
+	case "round_robin", "":
+		balanceStrategy = config.RoundRobin
+	default:
+		balanceStrategy = config.RoundRobin
+	}
+
+	// 创建负载均衡器
+	jwtBalancer = balancer.NewJWTBalancer(tokens, balanceStrategy)
+
+	// 创建并启动健康检查器
+	healthChecker = balancer.NewHealthChecker(jwtBalancer)
+	healthChecker.Start()
+
+	log.Printf("JWT balancer initialized with %d tokens, strategy: %s", len(tokens), string(balanceStrategy))
+	return nil
+}
+
+// ReloadConfig 重新加载配置
+func ReloadConfig() error {
+	if configManager == nil {
+		return fmt.Errorf("config manager not initialized")
+	}
+
+	// 重新加载配置
+	if err := configManager.LoadConfig(); err != nil {
+		return fmt.Errorf("failed to reload config: %v", err)
+	}
+
+	// 获取新配置
+	cfg := configManager.GetConfig()
+	tokens := configManager.GetJWTTokens()
+
+	if len(tokens) == 0 {
+		return fmt.Errorf("no JWT tokens in reloaded config")
+	}
+
+	// 更新负载均衡器
+	if jwtBalancer != nil {
+		jwtBalancer.RefreshTokens(tokens)
+	}
+
+	// 更新健康检查间隔
+	if healthChecker != nil && cfg.HealthCheckInterval > 0 {
+		healthChecker.SetCheckInterval(cfg.HealthCheckInterval)
+	}
+
+	log.Printf("Config reloaded successfully:")
+	log.Printf("  - Tokens: %d", len(tokens))
+	log.Printf("  - Strategy: %s", cfg.LoadBalanceStrategy)
+
+	return nil
+}
+
+// StopBalancer 停止负载均衡器
+func StopBalancer() {
+	if healthChecker != nil {
+		healthChecker.Stop()
+	}
+}
+
+// GetConfigManager 获取配置管理器
+func GetConfigManager() *config.Manager {
+	return configManager
+}
+
+func SendJetbrainsRequest(ctx context.Context, req *types.JetbrainsRequest) (*resty.Response, error) {
+	// 获取一个可用的JWT token
+	token, err := jwtBalancer.GetToken()
+	if err != nil {
+		log.Printf("failed to get JWT token: %v", err)
+		return nil, fmt.Errorf("no available JWT tokens: %v", err)
+	}
+
+	resp, err := utils.RestySSEClient.R().
+		SetContext(ctx).
+		SetHeader(types.JwtTokenKey, token).
+		SetDoNotParseResponse(true).
+		SetBody(req).
+		Post(types.ChatStreamV7)
+
+	if err != nil {
+		log.Printf("jetbrains ai req error: %v", err)
+		// 标记token为不健康
+		jwtBalancer.MarkTokenUnhealthy(token)
+		return nil, err
+	}
+
+	// 检查响应状态码
+	if resp.StatusCode() == 401 {
+		// 401表示token无效，标记为不健康
+		jwtBalancer.MarkTokenUnhealthy(token)
+		log.Printf("JWT token invalid (401): %s...", token[:min(len(token), 10)])
+		return nil, fmt.Errorf("JWT token invalid")
+	} else if resp.StatusCode() == 200 {
+		// 成功响应，确保token标记为健康
+		jwtBalancer.MarkTokenHealthy(token)
+	}
+
+	return resp, nil
+}
+
+// GetBalancerStats 获取负载均衡器统计信息
+func GetBalancerStats() (int, int) {
+	if jwtBalancer == nil {
+		return 0, 0
+	}
+	return jwtBalancer.GetHealthyTokenCount(), jwtBalancer.GetTotalTokenCount()
+}
+
+// min 辅助函数
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

internal/jetbrains/sse.go

@@ -0,0 +1,331 @@
+package jetbrains
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"github.com/bytedance/sonic"
+	"github.com/sashabaranov/go-openai"
+	"io"
+	"jetbrains-ai-proxy/internal/utils"
+	"log"
+	"math"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	sseObject         = "chat.completion.chunk"
+	completionsObject = "chat.completions"
+	sseFinish         = "[DONE]"
+	initialBufferSize = 4096
+	maxBufferSize     = 1024 * 1024 // 1MB
+	flushThreshold    = 10
+	heartbeatInterval = 30 * time.Second
+)
+
+type SSEData struct {
+	Type      string       `json:"type"`
+	EventType string       `json:"event_type"`
+	Content   string       `json:"content,omitempty"`
+	Reason    string       `json:"reason,omitempty"`
+	Updated   *UpdatedData `json:"updated,omitempty"`
+	Spent     *SpentData   `json:"spent,omitempty"`
+}
+
+type UpdatedData struct {
+	License string     `json:"license"`
+	Current AmountData `json:"current"`
+	Maximum AmountData `json:"maximum"`
+	Until   int64      `json:"until"`
+	QuotaID QuotaInfo  `json:"quotaID"`
+}
+
+type AmountData struct {
+	Amount string `json:"amount"`
+}
+
+type QuotaInfo struct {
+	QuotaId string `json:"quotaId"`
+}
+
+type SpentData struct {
+	Amount string `json:"amount"`
+}
+
+// ResponseJetbrainsAIToClient 处理非流式响应
+func ResponseJetbrainsAIToClient(ctx context.Context, req openai.ChatCompletionRequest, r io.Reader, fp string) (openai.ChatCompletionResponse, error) {
+	reader := bufio.NewReader(r)
+	var fullContent strings.Builder
+
+	now := time.Now().Unix()
+	chatId := strconv.Itoa(int(now))
+
+	for {
+		select {
+		case <-ctx.Done():
+			return openai.ChatCompletionResponse{}, ctx.Err()
+		default:
+		}
+
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				log.Printf("Reached EOF for non-streaming response")
+				break
+			}
+			return openai.ChatCompletionResponse{}, fmt.Errorf("读取错误: %w", err)
+		}
+
+		if !strings.HasPrefix(line, "data: ") {
+			continue
+		}
+
+		jsonStr := strings.TrimSpace(strings.TrimPrefix(line, "data: "))
+		if jsonStr == "" || jsonStr == sseFinish || jsonStr == "end" {
+			continue
+		}
+
+		var sseData SSEData
+		if err := sonic.UnmarshalString(jsonStr, &sseData); err != nil {
+			log.Printf("解析SSE数据错误: %v", err)
+			continue
+		}
+
+		if sseData.Type == "Content" {
+			fullContent.WriteString(sseData.Content)
+		}
+
+		if sseData.Type == "QuotaMetadata" {
+			var spentAmount float64
+			if sseData.Spent != nil {
+				if amount, err := strconv.ParseFloat(sseData.Spent.Amount, 64); err == nil {
+					spentAmount = amount
+				} else {
+					log.Printf("Warning: failed to parse spent amount '%s': %v", sseData.Spent.Amount, err)
+				}
+			}
+			usage := utils.CalculateJetbrainsUsage(fullContent.String(), int(math.Round(spentAmount)))
+			return createMessage(chatId, now, req, usage, fullContent.String(), fp), nil
+		}
+	}
+
+	// 如果没有收到 QuotaMetadata，返回默认响应
+	usage := utils.CalculateJetbrainsUsage(fullContent.String(), 0)
+	return createMessage(chatId, now, req, usage, fullContent.String(), fp), nil
+}
+
+// StreamJetbrainsAISSEToClient 处理流式响应
+func StreamJetbrainsAISSEToClient(ctx context.Context, req openai.ChatCompletionRequest, w io.Writer, r io.Reader, fp string) error {
+	log.Printf("=== Starting SSE Stream Processing for model: %s ===", req.Model)
+
+	reader := bufio.NewReaderSize(r, initialBufferSize)
+	writer := bufio.NewWriterSize(w, initialBufferSize)
+
+	now := time.Now().Unix()
+	chatId := strconv.Itoa(int(now))
+	fingerprint := fp
+
+	log.Printf("Session initialized - ChatID: %s, Fingerprint: %s", chatId, fingerprint)
+
+	var completionBuilder strings.Builder
+	messageCount := 0
+	totalBufferSize := 0
+
+	// 创建心跳检测器
+	heartbeat := time.NewTicker(heartbeatInterval)
+	defer heartbeat.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-heartbeat.C:
+			if err := sendHeartbeat(writer, w); err != nil {
+				log.Printf("Heartbeat error: %v", err)
+			}
+			continue
+		default:
+		}
+
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				log.Printf("Reached EOF after %d messages", messageCount)
+				return nil
+			}
+			return fmt.Errorf("read error: %w", err)
+		}
+
+		log.Printf("Received line: %s", strings.TrimSpace(line))
+
+		// 检查缓冲区大小
+		totalBufferSize += len(line)
+		if totalBufferSize > maxBufferSize {
+			log.Printf("Buffer overflow: current size %d exceeds max size %d", totalBufferSize, maxBufferSize)
+			return fmt.Errorf("buffer overflow: exceeded maximum buffer size of %d bytes", maxBufferSize)
+		}
+
+		if !strings.HasPrefix(line, "data: ") {
+			continue
+		}
+
+		jsonStr := strings.TrimSpace(strings.TrimPrefix(line, "data: "))
+		if jsonStr == "" || jsonStr == "end" {
+			continue
+		}
+
+		var sseData SSEData
+		if err := sonic.UnmarshalString(jsonStr, &sseData); err != nil {
+			log.Printf("Error unmarshaling SSE data: %v", err)
+			continue
+		}
+
+		log.Printf("Received SSE data: %+v", sseData)
+
+		messageCount++
+
+		if err := processMessage(writer, w, sseData, chatId, fingerprint, now, &completionBuilder, req); err != nil {
+			log.Printf("Failed to process message: %v", err)
+			return err
+		}
+
+		// 定期刷新缓冲区
+		if messageCount >= flushThreshold {
+			if err := flushWriter(writer, w); err != nil {
+				return fmt.Errorf("flush error: %w", err)
+			}
+			messageCount = 0
+		}
+
+		// 检查是否结束
+		if sseData.Type == "QuotaMetadata" {
+			if err := sendFinishSignal(writer, w); err != nil {
+				return fmt.Errorf("finish signal error: %w", err)
+			}
+			log.Printf("Stream completed successfully")
+			return nil
+		}
+	}
+}
+
+// processMessage 处理单个消息
+func processMessage(writer *bufio.Writer, w io.Writer, sseData SSEData, chatId, fingerprint string, now int64, completionBuilder *strings.Builder, req openai.ChatCompletionRequest) error {
+	switch sseData.Type {
+	case "Content":
+		completionBuilder.WriteString(sseData.Content)
+		sseMsg := createStreamMessage(chatId, now, req, fingerprint, sseData.Content, "")
+		return sendMessage(writer, w, sseMsg)
+
+	case "QuotaMetadata":
+		var spentAmount float64
+		if sseData.Spent != nil {
+			if amount, err := strconv.ParseFloat(sseData.Spent.Amount, 64); err == nil {
+				spentAmount = amount
+			} else {
+				log.Printf("Warning: failed to parse spent amount '%s': %v", sseData.Spent.Amount, err)
+			}
+		}
+
+		usage := utils.CalculateJetbrainsUsage(completionBuilder.String(), int(math.Round(spentAmount)))
+		sseMsg := createStreamMessage(chatId, now, req, fingerprint, "", "")
+		sseMsg.Choices[0].FinishReason = openai.FinishReasonStop
+		sseMsg.Usage = &usage
+		return sendMessage(writer, w, sseMsg)
+
+	default:
+		// 忽略其他类型的消息
+		log.Printf("Ignoring message type: %s", sseData.Type)
+		return nil
+	}
+}
+
+// createStreamMessage 创建流式消息
+func createStreamMessage(chatId string, now int64, req openai.ChatCompletionRequest, fingerPrint string, content string, reasoningContent string) openai.ChatCompletionStreamResponse {
+	choice := openai.ChatCompletionStreamChoice{
+		Index: 0,
+		Delta: openai.ChatCompletionStreamChoiceDelta{
+			Role:             openai.ChatMessageRoleAssistant,
+			Content:          content,
+			ReasoningContent: reasoningContent,
+		},
+		ContentFilterResults: openai.ContentFilterResults{},
+		FinishReason:         openai.FinishReasonNull,
+	}
+
+	return openai.ChatCompletionStreamResponse{
+		ID:                "chatcmpl-" + chatId,
+		Object:            sseObject,
+		Created:           now,
+		Model:             req.Model,
+		Choices:           []openai.ChatCompletionStreamChoice{choice},
+		SystemFingerprint: fingerPrint,
+	}
+}
+
+// createMessage 创建非流式消息响应
+func createMessage(chatId string, now int64, req openai.ChatCompletionRequest, usage openai.Usage, content string, fp string) openai.ChatCompletionResponse {
+	choice := openai.ChatCompletionChoice{
+		Index: 0,
+		Message: openai.ChatCompletionMessage{
+			Role:    openai.ChatMessageRoleAssistant,
+			Content: content,
+		},
+		FinishReason: openai.FinishReasonStop,
+	}
+
+	return openai.ChatCompletionResponse{
+		ID:                "chatcmpl-" + chatId,
+		Object:            completionsObject,
+		Created:           now,
+		Model:             req.Model,
+		Choices:           []openai.ChatCompletionChoice{choice},
+		SystemFingerprint: fp,
+		Usage:             usage,
+	}
+}
+
+// sendMessage 发送消息到客户端
+func sendMessage(writer *bufio.Writer, w io.Writer, sseMsg openai.ChatCompletionStreamResponse) error {
+	sendLine, err := sonic.MarshalString(sseMsg)
+	if err != nil {
+		return fmt.Errorf("marshal error: %w", err)
+	}
+
+	outputMsg := fmt.Sprintf("data: %s\n\n", sendLine)
+	if _, err := writer.WriteString(outputMsg); err != nil {
+		return fmt.Errorf("write error: %w", err)
+	}
+
+	return flushWriter(writer, w)
+}
+
+// sendHeartbeat 发送心跳包
+func sendHeartbeat(writer *bufio.Writer, w io.Writer) error {
+	if _, err := writer.WriteString(": keepalive\n\n"); err != nil {
+		return fmt.Errorf("heartbeat write error: %w", err)
+	}
+	return flushWriter(writer, w)
+}
+
+// sendFinishSignal 发送结束信号
+func sendFinishSignal(writer *bufio.Writer, w io.Writer) error {
+	finishMsg := fmt.Sprintf("data: %s\n\n", sseFinish)
+	if _, err := writer.WriteString(finishMsg); err != nil {
+		return fmt.Errorf("write finish signal error: %w", err)
+	}
+	return flushWriter(writer, w)
+}
+
+// flushWriter 刷新写入器
+func flushWriter(writer *bufio.Writer, w io.Writer) error {
+	if err := writer.Flush(); err != nil {
+		return fmt.Errorf("flush error: %w", err)
+	}
+	if f, ok := w.(http.Flusher); ok {
+		f.Flush()
+	}
+	return nil
+}

internal/middleware/auth.go

@@ -0,0 +1,31 @@
+package middleware
+
+import (
+	"github.com/labstack/echo"
+	"jetbrains-ai-proxy/internal/config"
+	"log"
+	"net/http"
+	"strings"
+)
+
+func BearerAuth() echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			// 获取Authorization header
+			auth := c.Request().Header.Get("Authorization")
+
+			if auth == "" || !strings.HasPrefix(auth, "Bearer ") {
+				return echo.NewHTTPError(http.StatusUnauthorized, "invalid authorization header")
+			}
+
+			token := strings.TrimPrefix(auth, "Bearer ")
+
+			if token != config.JetbrainsAiConfig.BearerToken || token == "" {
+				log.Printf("invalid token: %s", token)
+				return echo.NewHTTPError(http.StatusUnauthorized, "invalid token")
+			}
+
+			return next(c)
+		}
+	}
+}

internal/types/jetbrains.go

@@ -0,0 +1,131 @@
+package types
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/sashabaranov/go-openai"
+)
+
+const (
+	ChatStreamV7 = "https://api.jetbrains.ai/user/v5/llm/chat/stream/v7"
+	PROMPT       = "ij.chat.request.new-chat"
+	JwtTokenKey  = "grazie-authenticate-jwt"
+)
+
+var modelMap = map[string]OpenAIModel{
+	"gpt-4o":      {Object: "model", OwnedBy: "openai", Profile: "openai-gpt-4o"},
+	"o1":          {Object: "model", OwnedBy: "openai", Profile: "openai-o1"},
+	"o3":          {Object: "model", OwnedBy: "openai", Profile: "openai-o3"},
+	"o3-mini":     {Object: "model", OwnedBy: "openai", Profile: "openai-o3-mini"},
+	"o4-mini":     {Object: "model", OwnedBy: "openai", Profile: "openai-o4-mini"},
+	"gpt4.1":      {Object: "model", OwnedBy: "openai", Profile: "openai-gpt4.1"},
+	"gpt4.1-mini": {Object: "model", OwnedBy: "openai", Profile: "openai-gpt4.1-mini"},
+	"gpt4.1-nano": {Object: "model", OwnedBy: "openai", Profile: "openai-gpt4.1-nano"},
+
+	"gemini-pro-2.5":   {Object: "model", OwnedBy: "google", Profile: "google-chat-gemini-pro-2.5"},
+	"gemini-flash-2.0": {Object: "model", OwnedBy: "google", Profile: "google-chat-gemini-flash-2.0"},
+	"gemini-flash-2.5": {Object: "model", OwnedBy: "google", Profile: "google-chat-gemini-flash-2.5"},
+
+	"claude-3.5-haiku":  {Object: "model", OwnedBy: "anthropic", Profile: "anthropic-claude-3.5-haiku"},
+	"claude-3.5-sonnet": {Object: "model", OwnedBy: "anthropic", Profile: "anthropic-claude-3.5-sonnet"},
+	"claude-3.7-sonnet": {Object: "model", OwnedBy: "anthropic", Profile: "anthropic-claude-3.7-sonnet"},
+	"claude-4-sonnet":   {Object: "model", OwnedBy: "anthropic", Profile: "anthropic-claude-4-sonnet"},
+}
+
+type OpenAIModel struct {
+	ID      string `json:"id"`
+	Object  string `json:"object"`
+	OwnedBy string `json:"owned_by"`
+	Profile string `json:"profile"`
+}
+
+type OpenAIModelList struct {
+	Object string        `json:"object"`
+	Data   []OpenAIModel `json:"data"`
+}
+
+type MessageField struct {
+	Type    string `json:"type"`
+	Content string `json:"content,omitempty"`
+}
+
+type JetbrainsRequest struct {
+	Prompt  string    `json:"prompt"`
+	Profile string    `json:"profile"`
+	Chat    ChatField `json:"chat"`
+}
+
+type ChatField struct {
+	MessageField []MessageField `json:"messages"`
+}
+
+func ChatGPTToJetbrainsAI(chatReq openai.ChatCompletionRequest) (*JetbrainsRequest, error) {
+	messageFields, err := convertOpenAIMessagesToJetbrains(chatReq.Messages)
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert messages: %w", err)
+	}
+
+	openaiModel, err := GetModelByName(chatReq.Model)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get model: %w", err)
+	}
+
+	mReq := &JetbrainsRequest{
+		Prompt:  PROMPT,
+		Profile: openaiModel.Profile,
+		Chat: ChatField{
+			MessageField: messageFields,
+		},
+	}
+	if jsonData, err := json.MarshalIndent(mReq, "", "  "); err == nil {
+		fmt.Printf("mReq JSON: %s\n", string(jsonData))
+	}
+
+	return mReq, nil
+}
+
+func convertOpenAIMessagesToJetbrains(openaiMessages []openai.ChatCompletionMessage) ([]MessageField, error) {
+	var messageField []MessageField
+
+	for _, msg := range openaiMessages {
+		if msg.Role == "system" {
+			messageField = append(messageField, MessageField{
+				Type:    "system_message",
+				Content: msg.Content,
+			})
+		} else if msg.Role == "user" {
+			messageField = append(messageField, MessageField{
+				Type:    "user_message",
+				Content: msg.Content,
+			})
+		} else if msg.Role == "assistant" {
+			messageField = append(messageField, MessageField{
+				Type:    "assistant_message",
+				Content: msg.Content,
+			})
+		}
+	}
+	return messageField, nil
+}
+
+func GetModelByName(modelName string) (OpenAIModel, error) {
+	model, exists := modelMap[modelName]
+	if !exists {
+		return OpenAIModel{}, fmt.Errorf("model '%s' not found", modelName)
+	}
+	return model, nil
+}
+
+func GetSupportedModels() OpenAIModelList {
+	var modelSlice []OpenAIModel
+	for id, model := range modelMap {
+		modelWithID := model
+		modelWithID.ID = id
+		modelSlice = append(modelSlice, modelWithID)
+	}
+
+	return OpenAIModelList{
+		Object: "list",
+		Data:   modelSlice,
+	}
+}

internal/utils/req_client.go

@@ -0,0 +1,25 @@
+package utils
+
+import (
+	"crypto/tls"
+	"fmt"
+	"github.com/go-resty/resty/v2"
+	"time"
+)
+
+var (
+	RestySSEClient = resty.New().
+		SetTimeout(1 * time.Minute).
+		SetTLSClientConfig(&tls.Config{InsecureSkipVerify: true}).
+		SetDoNotParseResponse(true).
+		SetHeaders(map[string]string{
+			"Content-Type": "application/json",
+		}).
+		OnAfterResponse(func(c *resty.Client, resp *resty.Response) error {
+			if resp.StatusCode() != 200 {
+				return fmt.Errorf("Jetbrains API error: status %d, body: %s",
+					resp.StatusCode(), resp.String())
+			}
+			return nil
+		})
+)

internal/utils/string.go

@@ -0,0 +1,18 @@
+package utils
+
+import (
+	"math/rand"
+	"time"
+)
+
+var randSource = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+func RandStringUsingMathRand(n int) string {
+	var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
+
+	result := make([]rune, n)
+	for i := 0; i < n; i++ {
+		result[i] = letters[randSource.Intn(len(letters))]
+	}
+	return string(result)
+}

internal/utils/token.go

@@ -0,0 +1,27 @@
+package utils
+
+import (
+	"fmt"
+	"github.com/pkoukk/tiktoken-go"
+	"github.com/sashabaranov/go-openai"
+)
+
+func CalculateTokens(text string) int {
+	encoding := "cl100k_base"
+	tke, err := tiktoken.GetEncoding(encoding)
+	if err != nil {
+		err = fmt.Errorf("getEncoding: %v", err)
+		return 0
+	}
+	token := tke.Encode(text, nil, nil)
+	return len(token)
+}
+
+func CalculateJetbrainsUsage(completionText string, spent int) openai.Usage {
+	completionTokens := CalculateTokens(completionText)
+	return openai.Usage{
+		PromptTokens:     spent - completionTokens,
+		CompletionTokens: spent - completionTokens,
+		TotalTokens:      spent,
+	}
+}

main.go

@@ -0,0 +1,278 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"github.com/labstack/echo"
+	"github.com/labstack/echo/middleware"
+	"jetbrains-ai-proxy/internal/apiserver"
+	"jetbrains-ai-proxy/internal/config"
+	"jetbrains-ai-proxy/internal/jetbrains"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func main() {
+	// 定义命令行参数
+	configFile := flag.String("config", "", "配置文件路径")
+	port := flag.Int("p", 0, "服务器监听端口 (覆盖配置文件)")
+	host := flag.String("h", "", "服务器监听地址 (覆盖配置文件)")
+	jwtTokens := flag.String("c", "", "JWT Tokens值，多个token用逗号分隔 (覆盖配置文件)")
+	bearerToken := flag.String("k", "", "Bearer Token值 (覆盖配置文件)")
+	loadBalanceStrategy := flag.String("s", "", "负载均衡策略: round_robin 或 random (覆盖配置文件)")
+	generateConfig := flag.Bool("generate-config", false, "生成示例配置文件")
+	printConfig := flag.Bool("print-config", false, "打印当前配置信息")
+
+	flag.Usage = func() {
+		fmt.Printf("用法: %s [选项]\n\n", flag.CommandLine.Name())
+		fmt.Println("选项:")
+		flag.PrintDefaults()
+		fmt.Println("\n配置优先级 (从高到低):")
+		fmt.Println("  1. 命令行参数")
+		fmt.Println("  2. 环境变量")
+		fmt.Println("  3. 配置文件")
+		fmt.Println("  4. 默认值")
+		fmt.Println("\n配置方式:")
+		fmt.Println("  方式1 - 使用配置文件:")
+		fmt.Println("    ./jetbrains-ai-proxy --generate-config  # 生成示例配置")
+		fmt.Println("    # 编辑 config/config.json")
+		fmt.Println("    ./jetbrains-ai-proxy")
+		fmt.Println("")
+		fmt.Println("  方式2 - 使用环境变量:")
+		fmt.Println("    export JWT_TOKENS=\"jwt1,jwt2,jwt3\"")
+		fmt.Println("    export BEARER_TOKEN=\"your_token\"")
+		fmt.Println("    ./jetbrains-ai-proxy")
+		fmt.Println("")
+		fmt.Println("  方式3 - 使用命令行参数:")
+		fmt.Println("    ./jetbrains-ai-proxy -c \"jwt1,jwt2,jwt3\" -k \"bearer_token\"")
+		fmt.Println("")
+		fmt.Println("负载均衡策略:")
+		fmt.Println("  round_robin: 轮询策略（默认）")
+		fmt.Println("  random: 随机策略")
+	}
+
+	flag.Parse()
+
+	// 处理特殊命令
+	if *generateConfig {
+		if err := generateExampleConfig(); err != nil {
+			log.Fatalf("Failed to generate config: %v", err)
+		}
+		return
+	}
+
+	// 获取配置管理器
+	configManager := config.GetGlobalConfig()
+
+	// 如果指定了配置文件，设置环境变量
+	if *configFile != "" {
+		os.Setenv("CONFIG_FILE", *configFile)
+	}
+
+	// 加载配置
+	if err := configManager.LoadConfig(); err != nil {
+		log.Printf("Warning: %v", err)
+		log.Println("Continuing with command line arguments and environment variables...")
+	}
+
+	// 应用命令行参数覆盖
+	applyCommandLineOverrides(configManager, port, host, jwtTokens, bearerToken, loadBalanceStrategy)
+
+	// 打印配置信息
+	if *printConfig {
+		configManager.PrintConfig()
+		return
+	}
+
+	// 验证配置
+	if !configManager.HasJWTTokens() {
+		log.Fatal("No JWT tokens configured. Use --generate-config to create example configuration.")
+	}
+
+	cfg := configManager.GetConfig()
+	if cfg.BearerToken == "" {
+		log.Fatal("Bearer token is required. Please configure it in config file, environment variable, or command line.")
+	}
+
+	// 初始化JWT负载均衡器
+	if err := jetbrains.InitializeFromConfig(); err != nil {
+		log.Fatalf("Failed to initialize JWT balancer: %v", err)
+	}
+
+	// 设置优雅关闭
+	setupGracefulShutdown()
+
+	// 启动配置文件监控
+	discovery := config.NewConfigDiscovery(configManager)
+	discovery.WatchConfig()
+
+	// 创建Echo实例
+	e := echo.New()
+	e.Use(middleware.Logger())
+	e.Use(middleware.Recover())
+
+	// 添加管理端点
+	setupManagementEndpoints(e, configManager)
+
+	// 注册API路由
+	apiserver.RegisterRoutes(e)
+
+	// 启动服务器
+	addr := fmt.Sprintf("%s:%d", cfg.ServerHost, cfg.ServerPort)
+	log.Printf("Server starting on %s", addr)
+	configManager.PrintConfig()
+
+	if err := e.Start(addr); err != nil && !errors.Is(err, http.ErrServerClosed) {
+		log.Fatalf("start server error: %v", err)
+	}
+}
+
+// generateExampleConfig 生成示例配置
+func generateExampleConfig() error {
+	manager := config.NewManager()
+
+	// 生成JSON配置文件
+	if err := manager.GenerateExampleConfig("config/config.json"); err != nil {
+		return fmt.Errorf("failed to generate JSON config: %v", err)
+	}
+
+	// 生成.env示例文件
+	config.NewConfigDiscovery(manager)
+	envContent := `# JetBrains AI Proxy Configuration
+# Copy this file to .env and fill in your actual values
+
+# Multiple JWT tokens (comma-separated)
+JWT_TOKENS=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...,eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...
+
+# Bearer token for API authentication
+BEARER_TOKEN=your_bearer_token_here
+
+# Load balancing strategy: round_robin or random
+LOAD_BALANCE_STRATEGY=round_robin
+
+# Server configuration
+SERVER_HOST=0.0.0.0
+SERVER_PORT=8080
+`
+
+	if err := os.WriteFile(".env.example", []byte(envContent), 0644); err != nil {
+		return fmt.Errorf("failed to generate .env example: %v", err)
+	}
+
+	fmt.Println("✅ Example configuration files generated:")
+	fmt.Println("   📄 config/config.json - JSON configuration file")
+	fmt.Println("   📄 .env.example - Environment variables example")
+	fmt.Println("")
+	fmt.Println("📝 Next steps:")
+	fmt.Println("   1. Edit config/config.json with your JWT tokens")
+	fmt.Println("   2. Or copy .env.example to .env and edit it")
+	fmt.Println("   3. Run: ./jetbrains-ai-proxy")
+
+	return nil
+}
+
+// applyCommandLineOverrides 应用命令行参数覆盖
+func applyCommandLineOverrides(manager *config.Manager, port *int, host, jwtTokens, bearerToken, strategy *string) {
+	if *jwtTokens != "" {
+		manager.SetJWTTokens(*jwtTokens)
+		log.Printf("JWT tokens overridden by command line")
+	}
+
+	if *bearerToken != "" {
+		manager.SetBearerToken(*bearerToken)
+		log.Printf("Bearer token overridden by command line")
+	}
+
+	if *strategy != "" {
+		manager.SetLoadBalanceStrategy(*strategy)
+		log.Printf("Load balance strategy overridden by command line: %s", *strategy)
+	}
+
+	// 覆盖服务器配置
+	cfg := manager.GetConfig()
+	if *port > 0 {
+		cfg.ServerPort = *port
+		log.Printf("Server port overridden by command line: %d", *port)
+	}
+
+	if *host != "" {
+		cfg.ServerHost = *host
+		log.Printf("Server host overridden by command line: %s", *host)
+	}
+}
+
+// setupManagementEndpoints 设置管理端点
+func setupManagementEndpoints(e *echo.Echo, manager *config.Manager) {
+	// 健康检查端点
+	e.GET("/health", func(c echo.Context) error {
+		healthy, total := jetbrains.GetBalancerStats()
+		cfg := manager.GetConfig()
+
+		return c.JSON(http.StatusOK, map[string]interface{}{
+			"status":         "ok",
+			"healthy_tokens": healthy,
+			"total_tokens":   total,
+			"strategy":       cfg.LoadBalanceStrategy,
+			"server_info": map[string]interface{}{
+				"host": cfg.ServerHost,
+				"port": cfg.ServerPort,
+			},
+		})
+	})
+
+	// 配置信息端点
+	e.GET("/config", func(c echo.Context) error {
+		discovery := config.NewConfigDiscovery(manager)
+		summary := discovery.GetConfigSummary()
+		return c.JSON(http.StatusOK, summary)
+	})
+
+	// 重载配置端点
+	e.POST("/reload", func(c echo.Context) error {
+		if err := jetbrains.ReloadConfig(); err != nil {
+			return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+				"error": err.Error(),
+			})
+		}
+
+		return c.JSON(http.StatusOK, map[string]interface{}{
+			"message": "Configuration reloaded successfully",
+		})
+	})
+
+	// 负载均衡器统计端点
+	e.GET("/stats", func(c echo.Context) error {
+		healthy, total := jetbrains.GetBalancerStats()
+		cfg := manager.GetConfig()
+
+		return c.JSON(http.StatusOK, map[string]interface{}{
+			"balancer": map[string]interface{}{
+				"healthy_tokens": healthy,
+				"total_tokens":   total,
+				"strategy":       cfg.LoadBalanceStrategy,
+			},
+			"config": map[string]interface{}{
+				"health_check_interval": cfg.HealthCheckInterval.String(),
+				"server_host":           cfg.ServerHost,
+				"server_port":           cfg.ServerPort,
+			},
+		})
+	})
+}
+
+// setupGracefulShutdown 设置优雅关闭
+func setupGracefulShutdown() {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+
+	go func() {
+		<-c
+		log.Println("Shutting down gracefully...")
+		jetbrains.StopBalancer()
+		os.Exit(0)
+	}()
+}

start.sh

@@ -0,0 +1,200 @@
+#!/bin/bash
+
+# JetBrains AI Proxy 启动脚本
+# 支持自动配置发现和多种配置方式
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# 打印带颜色的消息
+print_info() {
+    echo -e "${BLUE}ℹ️  $1${NC}"
+}
+
+print_success() {
+    echo -e "${GREEN}✅ $1${NC}"
+}
+
+print_warning() {
+    echo -e "${YELLOW}⚠️  $1${NC}"
+}
+
+print_error() {
+    echo -e "${RED}❌ $1${NC}"
+}
+
+# 检查可执行文件
+check_executable() {
+    if [ ! -f "./jetbrains-ai-proxy" ]; then
+        print_error "可执行文件 './jetbrains-ai-proxy' 不存在"
+        print_info "请先编译项目: go build -o jetbrains-ai-proxy"
+        exit 1
+    fi
+    
+    if [ ! -x "./jetbrains-ai-proxy" ]; then
+        print_info "设置可执行权限..."
+        chmod +x ./jetbrains-ai-proxy
+    fi
+}
+
+# 检查配置
+check_configuration() {
+    print_info "检查配置..."
+    
+    # 检查是否存在配置文件
+    config_files=(
+        "config.json"
+        "config/config.json"
+        "configs/config.json"
+        ".config/jetbrains-ai-proxy.json"
+    )
+    
+    config_found=false
+    for config_file in "${config_files[@]}"; do
+        if [ -f "$config_file" ]; then
+            print_success "找到配置文件: $config_file"
+            config_found=true
+            break
+        fi
+    done
+    
+    # 检查环境变量
+    env_configured=false
+    if [ -n "$JWT_TOKENS" ] || [ -n "$JWT_TOKEN" ]; then
+        if [ -n "$BEARER_TOKEN" ]; then
+            print_success "检测到环境变量配置"
+            env_configured=true
+        else
+            print_warning "检测到JWT tokens但缺少BEARER_TOKEN环境变量"
+        fi
+    fi
+    
+    # 检查.env文件
+    if [ -f ".env" ]; then
+        print_success "找到 .env 文件"
+        env_configured=true
+    fi
+    
+    # 如果没有找到任何配置，生成示例配置
+    if [ "$config_found" = false ] && [ "$env_configured" = false ]; then
+        print_warning "未找到配置文件或环境变量配置"
+        print_info "生成示例配置文件..."
+        
+        if ./jetbrains-ai-proxy --generate-config; then
+            print_success "示例配置文件已生成"
+            print_info "请编辑 config/config.json 或 .env.example 文件"
+            print_info "然后重新运行此脚本"
+            exit 0
+        else
+            print_error "生成示例配置失败"
+            exit 1
+        fi
+    fi
+}
+
+# 显示配置信息
+show_config() {
+    print_info "当前配置信息:"
+    ./jetbrains-ai-proxy --print-config
+}
+
+# 启动服务
+start_service() {
+    print_info "启动 JetBrains AI Proxy..."
+    
+    # 如果有命令行参数，直接传递
+    if [ $# -gt 0 ]; then
+        print_info "使用命令行参数: $*"
+        exec ./jetbrains-ai-proxy "$@"
+    else
+        # 使用配置文件启动
+        exec ./jetbrains-ai-proxy
+    fi
+}
+
+# 显示帮助信息
+show_help() {
+    echo "JetBrains AI Proxy 启动脚本"
+    echo ""
+    echo "用法:"
+    echo "  $0                          # 使用配置文件启动"
+    echo "  $0 [options]                # 使用命令行参数启动"
+    echo "  $0 --help                   # 显示帮助信息"
+    echo "  $0 --config                 # 显示当前配置"
+    echo "  $0 --generate               # 生成示例配置文件"
+    echo ""
+    echo "配置方式 (优先级从高到低):"
+    echo "  1. 命令行参数"
+    echo "  2. 环境变量"
+    echo "  3. 配置文件 (config.json, config/config.json 等)"
+    echo "  4. 默认值"
+    echo ""
+    echo "示例:"
+    echo "  # 生成配置文件"
+    echo "  $0 --generate"
+    echo ""
+    echo "  # 使用配置文件启动"
+    echo "  $0"
+    echo ""
+    echo "  # 使用命令行参数启动"
+    echo "  $0 -c \"jwt1,jwt2,jwt3\" -k \"bearer_token\" -s random"
+    echo ""
+    echo "  # 使用环境变量启动"
+    echo "  export JWT_TOKENS=\"jwt1,jwt2,jwt3\""
+    echo "  export BEARER_TOKEN=\"your_token\""
+    echo "  $0"
+    echo ""
+    echo "管理端点:"
+    echo "  GET  /health    - 健康检查"
+    echo "  GET  /config    - 配置信息"
+    echo "  GET  /stats     - 统计信息"
+    echo "  POST /reload    - 重载配置"
+}
+
+# 主函数
+main() {
+    echo "🚀 JetBrains AI Proxy 启动脚本"
+    echo "================================"
+    
+    # 处理特殊参数
+    case "${1:-}" in
+        --help|-h)
+            show_help
+            exit 0
+            ;;
+        --config)
+            check_executable
+            show_config
+            exit 0
+            ;;
+        --generate)
+            check_executable
+            ./jetbrains-ai-proxy --generate-config
+            exit 0
+            ;;
+    esac
+    
+    # 检查可执行文件
+    check_executable
+    
+    # 检查配置
+    check_configuration
+    
+    # 启动服务
+    start_service "$@"
+}
+
+# 捕获中断信号
+trap 'print_info "正在停止服务..."; exit 0' INT TERM
+
+# 运行主函数
+main "$@"