Sun Jun 8 12:09:47 CST 2025

.clinerules

@@ -0,0 +1,166 @@
+# 自定义指令
+CUSTOM_INSTRUCTIONS = """
+# 基本配置
+env_tool（虚拟环境管理工具）: conda
+env_name(虚拟环境名称): api-proxy
+env_activate_cmd(激活虚拟环境命令): conda activate {env_tool}
+
+# 角色
+你是一个基于python开发工程师
+
+# 项目要求
+- 使用 fastapi 开发一个实现多种 api 代理转发的工具
+
+# 知识参考
+当你需要查询相关源码时，请访问下面的链接：
+
+---
+
+# 虚拟环境要求
+- 虚拟环境工具：{env_tool}
+- 使用名为{env_name}的虚拟环境，如果没有则创建，如果有则运行下面的命令行：{env_activate_cmd}
+
+# 项目管理
+- 使用 Memory Bank作为项目管理工具
+- 用户可以到当前目录下通过指令进行任务管理
+- Memory Bank 中使用中文记录的项目信息
+
+# 交流
+- 如非特别指明，必须使用中文进行交流
+- 如果需求不明确时，必须找用户进行需求调研，调研时，一次只提问一个问题
+
+"""
+# 自动批准规则
+AUTO_APPROVE = true
+
+
+---
+description: Describes Cline's Memory Bank system, its structure, and workflows for maintaining project knowledge across sessions.
+author: https://github.com/nickbaumann98
+version: 1.0
+tags: ["memory-bank", "knowledge-base", "core-behavior", "documentation-protocol"]
+globs: ["memory-bank/**/*.md", "*"]
+---
+# Cline's Memory Bank
+
+I am Cline, an expert software engineer with a unique characteristic: my memory resets completely between sessions. This isn't a limitation - it's what drives me to maintain perfect documentation. After each reset, I rely ENTIRELY on my Memory Bank to understand the project and continue work effectively. I MUST read ALL memory bank files at the start of EVERY task - this is not optional.
+
+## Memory Bank Structure
+
+The Memory Bank consists of core files and optional context files, all in Markdown format. Files build upon each other in a clear hierarchy:
+
+```mermaid
+flowchart TD
+    PB[projectbrief.md] --> PC[productContext.md]
+    PB --> SP[systemPatterns.md]
+    PB --> TC[techContext.md]
+    
+    PC --> AC[activeContext.md]
+    SP --> AC
+    TC --> AC
+    
+    AC --> P[progress.md]
+```
+
+### Core Files (Required)
+1. `projectbrief.md`
+   - Foundation document that shapes all other files
+   - Created at project start if it doesn't exist
+   - Defines core requirements and goals
+   - Source of truth for project scope
+
+2. `productContext.md`
+   - Why this project exists
+   - Problems it solves
+   - How it should work
+   - User experience goals
+
+3. `activeContext.md`
+   - Current work focus
+   - Recent changes
+   - Next steps
+   - Active decisions and considerations
+   - Important patterns and preferences
+   - Learnings and project insights
+
+4. `systemPatterns.md`
+   - System architecture
+   - Key technical decisions
+   - Design patterns in use
+   - Component relationships
+   - Critical implementation paths
+
+5. `techContext.md`
+   - Technologies used
+   - Development setup
+   - Technical constraints
+   - Dependencies
+   - Tool usage patterns
+
+6. `progress.md`
+   - What works
+   - What's left to build
+   - Current status
+   - Known issues
+   - Evolution of project decisions
+
+### Additional Context
+Create additional files/folders within memory-bank/ when they help organize:
+- Complex feature documentation
+- Integration specifications
+- API documentation
+- Testing strategies
+- Deployment procedures
+
+## Core Workflows
+
+### Plan Mode
+```mermaid
+flowchart TD
+    Start[Start] --> ReadFiles[Read Memory Bank]
+    ReadFiles --> CheckFiles{Files Complete?}
+    
+    CheckFiles -->|No| Plan[Create Plan]
+    Plan --> Document[Document in Chat]
+    
+    CheckFiles -->|Yes| Verify[Verify Context]
+    Verify --> Strategy[Develop Strategy]
+    Strategy --> Present[Present Approach]
+```
+
+### Act Mode
+```mermaid
+flowchart TD
+    Start[Start] --> Context[Check Memory Bank]
+    Context --> Update[Update Documentation]
+    Update --> Execute[Execute Task]
+    Execute --> Document[Document Changes]
+```
+
+## Documentation Updates
+
+Memory Bank updates occur when:
+1. Discovering new project patterns
+2. After implementing significant changes
+3. When user requests with **update memory bank** (MUST review ALL files)
+4. When context needs clarification
+
+```mermaid
+flowchart TD
+    Start[Update Process]
+    
+    subgraph Process
+        P1[Review ALL Files]
+        P2[Document Current State]
+        P3[Clarify Next Steps]
+        P4[Document Insights & Patterns]
+        
+        P1 --> P2 --> P3 --> P4
+    end
+    
+    Start --> Process
+```
+
+Note: When triggered by **update memory bank**, I MUST review every memory bank file, even if some don't require updates. Focus particularly on activeContext.md and progress.md as they track current state.
+
+REMEMBER: After every memory reset, I begin completely fresh. The Memory Bank is my only link to previous work. It must be maintained with precision and clarity, as my effectiveness depends entirely on its accuracy.

.gitignore

@@ -0,0 +1,3 @@
+**/__pycache__/
+README.md
+.env

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,191 @@
+from fastapi import FastAPI, Request, HTTPException, Response
+from fastapi.responses import StreamingResponse
+import httpx
+import logging
+import os, json
+import re  # 用于URL路径处理
+from pprint import pprint
+from key_selector import KeySelector
+
+def get_target_url(url: str) -> str:
+    """将url参数变了转换为合法的目标url；from http/ or https/ to http:// or https://"""
+    url = re.sub(r"^http/", "http://", url)
+    url = re.sub(r"^https/", "https://", url)
+    return url
+
+app = FastAPI()
+
+# 配置日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("uvicorn.error")
+
+# 从环境变量获取配置
+# UPSTREAM_HOST = os.getenv("UPSTREAM_HOST", "http://127.0.0.1")  # 必须包含端口号
+# AUTH_TOKEN = os.getenv("AUTH_TOKEN", "YIG8ANC8q2QxFV_Gf8qwkPdBj2EpsqGqlfc3qvSdg7ksVkZcokOUtQn43XGK0NK3UUdBlIkYzNWefco_Wu4RcKnB0kpNgtZ2nTeqNum0i3fTUEhEcWSlJtT8FQgRK7bi")  # 安全认证令牌
+X_Goog_Api_Key = os.getenv("X_Goog_Api_Key", "")
+
+@app.get("/")
+async def read_root():
+    return {"message": "FastAPI Proxy is running"}
+
+@app.post("/v25/{path:path}")
+async def proxy(request: Request, path: str):
+    # 添加流式请求判断逻辑
+    is_streaming = ":streamGenerateContent" in path.lower()
+    print(f"path: {path}")
+    # path = "https/generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
+    # target_url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
+    target_url = get_target_url(path)
+    # target_url = f"{target_url}?key={X_Goog_Api_Key}"
+    print(f"target_url: {target_url}")
+    method = request.method
+    headers = {k: v for k, v in request.headers.items()
+        # if k.lower() not in ["host", "connection", "Postman-Token", "content-length"]}
+        if k.lower() not in ["host", "content-length"]}
+    
+    key_selector = KeySelector()
+    # print('apikey',key_selector.get_api_key()['key_value'])
+
+    headers["X-Goog-Api-Key"] = key_selector.get_api_key()['key_value']
+    # print(key_selector.api_key_info.key_value)
+    # headers["host"] = "generativelanguage.googleapis.com"
+
+    try:
+        # 关键修复：禁用KeepAlive防止连接冲突
+        transport = httpx.AsyncHTTPTransport(retries=3, http1=True)
+
+        async with httpx.AsyncClient(
+            transport=transport,
+            timeout=httpx.Timeout(300.0, connect=30.0)
+        ) as client:
+            # 处理请求体
+            req_content = await request.body()
+            print(f"Request headers: {headers}")
+            # print(f"req_content: {req_content}")
+            # req_content_str = req_content.decode('utf-8')  # 假设内容是 UTF-8 编码
+            # print(f"req_content_str: {req_content_str}")
+            print(f'target_url: {target_url}')
+            print(f'method: {method}')
+            # 发送请求到上游服务
+            response = await client.request(
+                method=method,
+                url=target_url,
+                headers=headers,
+                content=req_content,
+                follow_redirects=True  # 自动处理重定向
+            )
+
+            if is_streaming:
+                # 流式响应处理
+                async def stream_generator():
+                    try:
+                        async for chunk in response.aiter_bytes():
+                            yield chunk
+                    except Exception as e:
+                        logger.error(f"Stream interrupted: {str(e)}")
+                        yield json.dumps({"error": "流中断"}).encode()
+            
+                # 移除冲突头部
+                headers = dict(response.headers)
+                headers.pop("Content-Length", None)
+            
+                return StreamingResponse(
+                    content=stream_generator(),
+                    status_code=response.status_code,
+                    headers=headers,
+                    media_type="application/x-ndjson"  # Gemini流式格式
+                )
+            else:
+
+                print(f"response.status_code: {response.status_code}")
+                print(f"response.text: {response.text}")
+                # 解析 JSON 字符串
+                try:
+                    data = json.loads(response.text)
+                    # 格式化输出 JSON 数据
+                    formatted_json = json.dumps(data, ensure_ascii=False, indent=4)
+                    print('formatted_json')
+                    print(formatted_json)
+                    # return formatted_json
+                    return Response(
+                        content=formatted_json,
+                        media_type="application/json"
+                    )
+                except json.JSONDecodeError as e:
+                    print(f"Error decoding JSON: {e}")
+
+
+        # # 详细记录错误响应
+        # if response.status_code >= 400:
+        #     error_detail = response.text[:1000]  # 增加错误详情长度
+        #     logger.error(f"Upstream error {response.status_code}: {error_detail}")
+        #     # 可选：记录完整响应到文件
+        #     # with open("error.log", "a") as f:
+        #     #     f.write(f"\n--- {target_url} ---\n{response.text}\n")
+
+        # # 流式传输响应
+        # return StreamingResponse(
+        #     content=response.aiter_bytes(),
+        #     status_code=response.status_code,
+        #     headers=dict(response.headers)
+        # )
+
+    except httpx.ConnectError as e:
+        logger.error(f"Connection failed to {target_url}: {e}")
+        raise HTTPException(502, f"无法连接到上游服务: {target_url}") # Modified error message
+    except httpx.ReadTimeout as e:
+        logger.error(f"Timeout: {e}")
+        raise HTTPException(504, "上游服务响应超时")
+    except httpx.HTTPError as e:  # 捕获所有HTTP异常
+        print('111111111111111111111')
+
+        try:
+            # 安全地获取异常信息
+            error_type = type(e).__name__
+
+            # 尝试获取状态码（如果存在）
+            status_code = getattr(e, 'response', None) and e.response.status_code
+
+            # 安全地获取错误详情
+            error_detail = ""
+            try:
+                # 尝试获取文本响应（限制长度）
+                if hasattr(e, 'response') and e.response:
+                    error_detail = e.response.text[:500]  # 只取前500个字符
+            except Exception as ex:
+                error_detail = f"无法获取错误详情: {type(ex).__name__}"
+
+            # 安全地记录日志
+            logger.error(
+                "HTTP代理错误 | "
+                f"类型: {error_type} | "
+                f"状态码: {status_code or 'N/A'} | "
+                f"目标URL: {target_url} | "
+                f"详情: {error_detail[:200]}"  # 日志中只记录前200字符
+            )
+
+            # 打印到控制台以便调试
+            print(f"111111111111111111111 - HTTP代理错误: {error_type}")
+            print(f"目标URL: {target_url}")
+            print(f"状态码: {status_code or 'N/A'}")
+            print(f"错误详情: {error_detail[:500]}")
+
+        except Exception as ex:
+            # 如果记录日志本身出错，使用最安全的方式记录
+            logger.error(f"记录HTTP错误时发生异常: {type(ex).__name__}")
+            print(f"严重错误: 记录HTTP错误时发生异常: {ex}")
+
+        # 返回用户友好的错误响应
+        raise HTTPException(
+            status_code=502,
+            detail=f"网关服务错误: {error_type} (上游状态: {status_code or '未知'})"
+        )
+
+
+        print('111111111111111111111')
+        # logger.error(f"HTTP error: {str(e)}")
+
+        raise HTTPException(502, f"网关错误: {str(e)}")
+    except Exception as e:
+        logger.exception("Unexpected proxy error")
+        raise HTTPException(500, f"内部服务器错误: {str(e)}")

key_selector.py

@@ -0,0 +1,15 @@
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+class KeySelector():
+    def __init__(self):
+        pass
+    
+    def get_api_key(self):
+        api_key_info = {
+            "key_at": "at_headers",
+            "key_name": "X_Goog_Api_Key",
+            "key_value": os.getenv("X_Goog_Api_Key", "")
+        }
+        return api_key_info

memory-bank/activeContext.md

@@ -0,0 +1,25 @@
+# 当前背景 (Active Context)
+
+## 当前工作重点
+初始化项目记忆库。
+
+## 最近的变更
+- 创建了 `projectbrief.md` 文件，定义了项目的核心目标和范围。
+- 创建了 `productContext.md` 文件，描述了项目的目的、解决的问题和用户体验目标。
+- 创建了 `systemPatterns.md` 文件，概述了系统架构、设计模式和关键组件。
+- 创建了 `techContext.md` 文件，记录了使用的技术、开发环境设置和技术约束。
+
+## 下一步计划
+- 创建 `progress.md` 文件，记录项目的当前状态、已完成和待完成的工作。
+- 根据项目需求，开始实现 FastAPI 应用的核心代理转发逻辑。
+- 定义和实现代理规则的配置加载机制。
+- 集成 HTTP 客户端库 (`httpx`) 进行后端请求转发。
+
+## 重要的模式和偏好
+- 优先使用异步编程。
+- 保持代码简洁和模块化。
+- 遵循 FastAPI 的最佳实践。
+
+## 学习和项目洞察
+- 项目处于初期阶段，主要任务是搭建基本框架和配置。
+- 需要仔细设计配置文件的结构，以便于灵活地添加和管理代理规则。

memory-bank/productContext.md

@@ -0,0 +1,22 @@
+# 产品背景 (Product Context)
+
+## 项目目的
+本项目旨在开发一个灵活的 API 代理转发工具，以解决在微服务架构或集成不同第三方服务时遇到的跨域、认证、请求/响应格式不一致等问题。通过集中管理 API 访问，简化客户端与多个后端服务之间的交互。
+
+## 解决的问题
+- **跨域问题**: 允许客户端通过单一来源访问不同域的 API。
+- **API 集成**: 简化集成多个内部或外部 API 的过程。
+- **请求/响应转换**: 提供一个中心点来标准化或修改请求和响应数据。
+- **配置管理**: 集中管理所有代理目标的配置。
+
+## 用户体验目标
+- **开发者**: 易于配置和扩展新的代理规则。
+- **系统管理员**: 易于部署和管理。
+- **最终用户**: 无感知地通过代理访问后端服务。
+
+## 功能愿景
+- 支持基于路径、请求方法等多种匹配规则进行转发。
+- 支持请求头、请求体、查询参数的修改。
+- 支持响应头、响应体的修改。
+- 易于集成认证和授权机制（未来可能）。
+- 提供基本的日志记录功能。

memory-bank/progress.md

@@ -0,0 +1,31 @@
+# 项目进度 (Progress)
+
+## 当前状态
+项目记忆库已初始化。核心记忆文件（projectbrief.md, productContext.md, systemPatterns.md, techContext.md, activeContext.md）已创建。
+
+## 已完成的工作
+- 创建了 Memory Bank 目录。
+- 创建并填充了以下记忆文件：
+    - `projectbrief.md`
+    - `productContext.md`
+    - `systemPatterns.md`
+    - `techContext.md`
+    - `activeContext.md`
+
+## 待完成的工作
+- 实现 FastAPI 应用的核心代理转发逻辑。
+- 设计和实现代理规则的配置加载机制。
+- 集成 `httpx` 库进行后端请求转发。
+- 添加基本的日志记录功能。
+- 根据需求实现请求/响应转换功能。
+- 编写单元测试和集成测试。
+- 完善 Dockerfile。
+- 编写详细的 README.md 文档。
+
+## 已知问题
+- 暂无已知问题。
+
+## 项目决策演变
+- 决定使用 FastAPI 作为后端框架，因为它提供了高性能和易于使用的异步支持。
+- 决定使用 `httpx` 作为 HTTP 客户端，因为它支持异步请求。
+- 决定使用配置文件来管理代理规则，以提高灵活性。

memory-bank/projectbrief.md

@@ -0,0 +1,26 @@
+# 项目简报 (Project Brief)
+
+## 项目名称
+API 代理转发工具
+
+## 核心目标
+使用 FastAPI 开发一个实现多种 API 代理转发的工具。
+
+## 主要需求
+- 能够接收来自客户端的请求。
+- 根据配置将请求转发到不同的后端 API。
+- 处理请求和响应的转换（如果需要）。
+- 支持多种 API 的代理。
+
+## 范围
+本项目专注于构建核心的代理转发功能。
+
+## 非范围
+- 高级安全功能（如认证、授权）除非明确要求。
+- 复杂的负载均衡策略除非明确要求。
+- 详细的监控和日志分析除非明确要求。
+
+## 成功标准
+- 能够成功代理转发至少两种不同的 API 请求。
+- 代码结构清晰，易于扩展新的代理目标。
+- 满足基本的性能要求。

memory-bank/systemPatterns.md

@@ -0,0 +1,32 @@
+# 系统模式 (System Patterns)
+
+## 架构概述
+本项目将采用基于 FastAPI 的微服务架构。核心是一个 FastAPI 应用，负责接收所有进来的请求，并根据配置将请求转发到相应的后端服务。
+
+```mermaid
+graph LR
+    Client --> Proxy[FastAPI Proxy]
+    Proxy --> BackendA[Backend Service A]
+    Proxy --> BackendB[Backend Service B]
+    Proxy --> BackendC[Backend Service C]
+```
+
+## 设计模式
+- **API Gateway Pattern**: FastAPI 应用充当 API 网关，作为客户端访问后端服务的单一入口点。
+- **Configuration Pattern**: 代理规则将通过配置文件进行管理，以便于修改和扩展。
+- **Middleware Pattern**: 利用 FastAPI 的中间件功能处理请求和响应的通用逻辑（如日志、认证等）。
+
+## 关键组件
+- **FastAPI Application**: 核心应用，处理路由和请求转发。
+- **Configuration Loader**: 负责加载和解析代理规则配置文件。
+- **HTTP Client**: 用于向后端服务发起请求（例如使用 `httpx` 库）。
+- **Request/Response Transformer (Optional)**: 根据配置修改请求和响应。
+
+## 数据流
+1. 客户端发起请求到 FastAPI Proxy。
+2. FastAPI Proxy 接收请求。
+3. Configuration Loader 解析配置，查找匹配的代理规则。
+4. 如果找到匹配规则，HTTP Client 根据规则向后端服务发起请求。
+5. 后端服务返回响应。
+6. Request/Response Transformer (如果存在) 修改响应。
+7. FastAPI Proxy 将响应返回给客户端。

memory-bank/techContext.md

@@ -0,0 +1,26 @@
+# 技术背景 (Tech Context)
+
+## 使用的技术
+- **后端框架**: FastAPI (Python)
+- **异步 HTTP 客户端**: httpx
+- **配置管理**: 可能使用 `python-dotenv` 或其他配置库来加载配置文件。
+- **依赖管理**: pip 和 requirements.txt
+- **容器化**: Docker
+
+## 开发环境设置
+1. 克隆仓库。
+2. 创建并激活 Conda 虚拟环境 (`conda create -n api-proxy python=3.9` 或使用现有环境，然后 `conda activate api-proxy`)。
+3. 安装依赖 (`pip install -r requirements.txt`)。
+4. 运行应用 (`uvicorn app:app --reload`)。
+
+## 技术约束
+- 需要 Python 3.7+。
+- 依赖于 FastAPI 和 httpx 库。
+
+## 依赖关系
+- `requirements.txt` 文件列出了所有必要的 Python 依赖。
+
+## 工具使用模式
+- 使用 `uvicorn` 作为 ASGI 服务器运行 FastAPI 应用。
+- 使用 `pip` 管理 Python 包。
+- 使用 Docker 构建和运行容器。

push.sh

@@ -0,0 +1,3 @@
+git add .
+git commit -m "$(date)"
+git push

requirements.txt

@@ -0,0 +1,3 @@
+fastapi
+uvicorn[standard]
+httpx