update

api_key_sb.py

@@ -20,30 +20,53 @@ def get_supabase_client() -> Client:
 
 supabase: Client = get_supabase_client()
 
-async def get_api_key_info(model: str = None):
+# async def get_api_key_info(api_type_name: str, lookup_value: str):
+#     """
+#     根据 API 类型名称和查找值从 Supabase 获取 API 密钥信息。
+#     """
+#     try:
+#         # 直接从 airs_model_api_keys_view_v1 视图中查询
+#         response = supabase.from_('airs_model_api_keys_view_v1').select('api_key, api_key_id').eq('api_type', api_type_name).eq('model_name', lookup_value).order('api_key_created_at', desc=False).limit(1).execute()
+        
+#         if response.data:
+#             api_key_info = response.data[0]
+#             # 视图返回的 id 是 api_key_id，需要将其映射为 'id' 以保持与之前逻辑的兼容性
+#             formatted_api_key_info = {
+#                 'api_key': api_key_info.get('api_key'),
+#                 'id': api_key_info.get('api_key_id')
+#             }
+#             # 在返回api_key_info之前，更新其ran_at字段
+#             await update_api_key_ran_at(formatted_api_key_info.get('id'))
+#             return formatted_api_key_info
+#         return None
+#     except Exception as e:
+#             logger.error(f"Error fetching API key info from view: {e}")
+#             return None
+
+async def get_api_key_info(lookup_value: str):
+    """
+    根据 API 类型名称和查找值从 Supabase 获取 API 密钥信息。
+    """
     try:
-        # 根据用户提供的SQL语句修改，从 'airs_model_api_keys_view' 视图中获取 'api_key'
-        if model:
-            response = supabase.from_('airs_model_api_keys_view').select('api_key', 'api_key_id').eq('model_name', model).order('api_key_ran_at', desc=False).limit(1).execute()
-        else:
-            # 如果没有提供model，则获取所有模型的api_key
-            raise HTTPException(status_code=400, detail="请提供模型名称！")
+        # 直接从 airs_model_api_keys_view_v1 视图中查询
+        response = supabase.from_('airs_model_api_keys_view_v1').select('api_key, api_key_id').eq('model_name', lookup_value).order('api_key_created_at', desc=False).limit(1).execute()
         
         if response.data:
             api_key_info = response.data[0]
+            # 视图返回的 id 是 api_key_id，需要将其映射为 'id' 以保持与之前逻辑的兼容性
+            formatted_api_key_info = {
+                'api_key': api_key_info.get('api_key'),
+                'id': api_key_info.get('api_key_id')
+            }
             # 在返回api_key_info之前，更新其ran_at字段
-            await update_api_key_ran_at(api_key_info.get('api_key_id'))
-            return api_key_info
-        else:
-            logger.error(f"未找到模型 '{model}' 的API密钥信息。")
-            raise HTTPException(status_code=404, detail=f"未找到模型 '{model}' 的API密钥信息。", headers={"X-Error-Type": "APIKeyNotFound"})
-    except HTTPException as e:
-        raise e # 重新抛出已有的HTTPException
+            await update_api_key_ran_at(formatted_api_key_info.get('id'))
+            return formatted_api_key_info
+        return None
     except Exception as e:
-        logger.error(f"从Supabase获取API密钥失败: {e}")
-        raise HTTPException(status_code=500, detail=f"从Supabase获取API密钥失败: {e}", headers={"X-Error-Type": "SupabaseFetchError"})
+            logger.error(f"Error fetching API key info from view: {e}")
+            return None
 
-async def update_api_key_ran_at(api_key_id: str, ran_at_time: datetime = None):
+async def update_api_key_ran_at(api_key_id: int, ran_at_time: datetime = None):
     """
     Updates the 'ran_at' field for a given API key in Supabase.
     If ran_at_time is None, it defaults to the current Beijing time.
@@ -58,11 +81,11 @@ async def update_api_key_ran_at(api_key_id: str, ran_at_time: datetime = None):
             current_local_time = ran_at_time.isoformat()
 
         logger.info(f"尝试更新 API 密钥 {api_key_id} 的 ran_at 为 {current_local_time}")
-        response = supabase.table("airs_api_keys").update({"ran_at": current_local_time}).eq("id", api_key_id).execute()
+        response = supabase.table("airs_api_keys_v1").update({"ran_at": current_local_time}).eq("id", api_key_id).execute()
         logger.info(f'API 密钥 {api_key_id} 的 ran_at 更新成功为 {current_local_time}. ')
 
         # 验证更新是否成功
-        verification_response = supabase.from_('airs_api_keys').select('ran_at').eq('id', api_key_id).single().execute()
+        verification_response = supabase.from_('airs_api_keys_v1').select('ran_at').eq('id', api_key_id).single().execute()
         verified_ran_at = verification_response.data.get('ran_at')
         logger.info(f"验证：API 密钥 {api_key_id} 的实际 ran_at 值为 {verified_ran_at}")
 

app.py

@@ -54,6 +54,7 @@ async def health_check():
 # @app.api_route("/v1/{protocol}/{host}/{path:path}", methods=["POST"])
 async def proxy(request: Request, protocol: ProtocolType, host:str, path: str, proxy_api_key: str = Depends(verify_proxy_api_key)): # 添加代理认证依赖
     real_url = f"{protocol.value}://{host}/{path}"
+    
     # 提取客户端请求的headers和body
     client_headers = dict(request.headers)
     client_body = await request.body()

docs/api_key_management_solution_v1.md

@@ -0,0 +1,260 @@
+# API 密钥管理方案
+
+本文档概述了 `airs_api_keys` 表的数据库存储、查询和代码建议方案，以支持 LLM 和搜索引擎 API 密钥的灵活管理。
+
+## 1. `airs_api_keys` 表的原始结构
+
+```sql
+create table public.airs_api_keys (
+  id bigint generated by default as identity not null,
+  created_at timestamp with time zone not null default now(),
+  api_key text null,
+  ran_at timestamp without time zone null default now(),
+  provider_id bigint null,
+  constraint airs_api_keys_pkey primary key (id),
+  constraint airs_api_keys_provider_id_fkey foreign KEY (provider_id) references airs_api_providers (id)
+) TABLESPACE pg_default;
+```
+
+## 2. `airs_api_keys` 表的建议修改结构
+
+为了支持不同类型的 API 密钥（LLM 和搜索引擎）以及更灵活的查找机制，建议修改 `airs_api_keys` 表结构如下：
+
+```sql
+create table public.airs_api_keys (
+  id bigint generated by default as identity not null,
+  created_at timestamp with time zone not null default now(),
+  api_key text null,
+  ran_at timestamp without time zone null default now(),
+  provider_id bigint null,
+  api_type text not null, -- 'llm' or 'search'
+  lookup_key text not null, -- LLM 的模型名称 (e.g., 'glm-4', 'gemini-pro'), 搜索引擎的域名或特定路径 (e.g., 'api.tavily.com')
+  url_pattern text null, -- 可选: 用于验证或更精确匹配的 URL 模式 (e.g., 'https://open.bigmodel.cn/api/paas/v4/chat/completions')
+  constraint airs_api_keys_pkey primary key (id),
+  constraint airs_api_keys_provider_id_fkey foreign KEY (provider_id) references airs_api_providers (id),
+  constraint airs_api_keys_unique_lookup_key unique (api_type, lookup_key) -- 确保每种类型和查找键组合的唯一性
+) TABLESPACE pg_default;
+```
+
+**字段说明：**
+
+* `api_type`: 字符串类型，用于区分 API 密钥的类型，例如 `'llm'` 或 `'search'`。
+* `lookup_key`: 字符串类型，作为查询 API 密钥的关键字段。
+  * 对于 LLM 类 API，这将是请求体中 `model` 字段的值（例如 `glm-4`, `gemini-pro`）。
+  * 对于搜索引擎类 API，这将是其域名或特定路径（例如 `api.tavily.com`）。
+* `url_pattern`: 可选的字符串类型，用于存储与 API 密钥关联的完整或部分 URL 模式。这可以用于在某些情况下进行额外的验证或更精确的匹配。
+* `constraint airs_api_keys_unique_lookup_key`: 确保 `api_type` 和 `lookup_key` 的组合是唯一的，防止重复的 API 密钥配置。
+
+### 示例数据库记录
+
+以下是一些 `airs_api_keys` 表中可能存在的示例记录：
+
+| id  | created_at             | api_key                    | ran_at              | provider_id | api_type | lookup_key     | url_pattern                                                              |
+| --- | ---------------------- | -------------------------- | ------------------- | ----------- | -------- | -------------- | ------------------------------------------------------------------------ |
+| 1   | 2023-01-01 10:00:00+00 | sk-xxxxxxxxxxxxxxxxxxxxglm | 2023-01-01 10:00:00 | 1           | llm      | glm-4          | https://open.bigmodel.cn/api/paas/v4/chat/completions                    |
+| 2   | 2023-01-02 11:00:00+00 | AIzaSyBxxxxxxxxxxxxxxxxxx  | 2023-01-02 11:00:00 | 2           | llm      | gemini-pro     | https://generativelanguage.googleapis.com/v1beta/openai/chat/completions |
+| 3   | 2023-01-03 12:00:00+00 | tvly-xxxxxxxxxxxxxxxxxxxx  | 2023-01-03 12:00:00 | 3           | search   | api.tavily.com | https://api.tavily.com/search                                            |
+
+## 3. 数据库查询方案
+
+根据修改后的表结构，可以按 `api_type` 和 `lookup_key` 高效地查询 API 密钥。
+
+### 查询 LLM API 密钥
+
+当代理服务收到 LLM 请求时，它会从请求体中提取 `model` 名称，并使用它作为 `lookup_key` 进行查询。
+
+```sql
+SELECT api_key, provider_id
+FROM public.airs_api_keys
+WHERE api_type = 'llm' AND lookup_key = :model_name;
+```
+
+* `:model_name` 将替换为从请求体中解析出的模型名称，例如 `'glm-4'` 或 `'gemini-pro'`。
+
+### 查询搜索引擎 API 密钥
+
+当代理服务收到搜索引擎请求时，它会根据请求的 URL 识别出对应的域名或特定路径，并使用它作为 `lookup_key` 进行查询。
+
+```sql
+SELECT api_key, provider_id
+FROM public.airs_api_keys
+WHERE api_type = 'search' AND lookup_key = :domain_or_path;
+```
+
+* `:domain_or_path` 将替换为从请求 URL 中提取的域名或路径，例如 `'api.tavily.com'`。
+
+## 4. 代码建议方案
+
+为了在 FastAPI 代理服务中实现 API 密钥的动态获取和注入，需要修改 `api_key_sb.py` 和 `proxy.py` 文件。
+
+### `api_key_sb.py` 中的 `get_api_key_info` 函数
+
+修改 `get_api_key_info` 函数以接受 `api_type` 和 `lookup_value` 作为参数，并根据这些参数从 Supabase 查询 API 密钥。
+
+```python
+# api_key_sb.py
+
+from supabase import create_client, Client
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+async def get_api_key_info(api_type: str, lookup_value: str):
+    """
+    根据 API 类型和查找值从 Supabase 获取 API 密钥信息。
+    """
+    try:
+        response = supabase.from_('airs_api_keys').select('api_key, provider_id').eq('api_type', api_type).eq('lookup_key', lookup_value).limit(1).execute()
+        if response.data:
+            return response.data[0]
+        return None
+    except Exception as e:
+        print(f"Error fetching API key info: {e}")
+        return None
+```
+
+### `proxy.py` 中的请求处理逻辑
+
+在 `proxy.py` 中，需要修改请求处理逻辑以：
+
+1. 识别传入请求的 API 类型（LLM 或搜索引擎）。
+2. 根据 API 类型从请求中提取相应的 `lookup_value`（`model` 名称或域名/路径）。
+3. 调用 `get_api_key_info` 获取 API 密钥。
+4. 将获取到的 API 密钥注入到转发请求的相应位置（例如，请求头或请求体）。
+
+以下是 `proxy.py` 中 `handle_proxy_request` 函数的伪代码片段：
+
+```python
+# proxy.py
+
+from fastapi import FastAPI, Request, Response, HTTPException
+from fastapi.responses import StreamingResponse
+import httpx
+import json
+import logging
+import re
+from api_key_sb import get_api_key_info # 导入新的函数
+
+# 配置日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+client = httpx.AsyncClient()
+
+# 统一错误响应格式
+def create_error_response(status_code: int, message: str):
+    return Response(
+        content=json.dumps({"error": {"message": message, "type": "proxy_error"}}),
+        status_code=status_code,
+        media_type="application/json"
+    )
+
+@app.api_route("/v1/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"])
+async def handle_proxy_request(request: Request, path: str):
+    target_url_base = path # 假设 path 已经包含了目标 URL 的基础部分
+    api_key = None
+    api_type = None
+    lookup_value = None
+
+    # 识别 API 类型并提取 lookup_value
+    if "open.bigmodel.cn" in target_url_base or "generativelanguage.googleapis.com" in target_url_base:
+        api_type = "llm"
+        try:
+            request_body = await request.json()
+            lookup_value = request_body.get("model")
+            if not lookup_value:
+                logger.warning(f"LLM request missing 'model' in body for path: {path}")
+                return create_error_response(400, "LLM request body must contain 'model' field.")
+        except json.JSONDecodeError:
+            logger.warning(f"LLM request body is not valid JSON for path: {path}")
+            return create_error_response(400, "LLM request body must be valid JSON.")
+    elif "api.tavily.com" in target_url_base:
+        api_type = "search"
+        lookup_value = "api.tavily.com" # 或者从 URL 中更动态地提取，例如使用正则表达式
+    else:
+        logger.warning(f"Unknown API type for path: {path}")
+        return create_error_response(400, "Unknown API type or unsupported target URL.")
+
+    # 从数据库获取 API 密钥
+    if api_type and lookup_value:
+        api_key_info = await get_api_key_info(api_type, lookup_value)
+        if api_key_info:
+            api_key = api_key_info["api_key"]
+            logger.info(f"Successfully retrieved API key for type: {api_type}, lookup_value: {lookup_value}")
+        else:
+            logger.warning(f"API Key not found for type: {api_type}, lookup_value: {lookup_value}")
+            return create_error_response(401, "API Key not found for the requested service.")
+    else:
+        logger.error(f"Failed to determine API type or lookup value for path: {path}")
+        return create_error_response(500, "Internal server error: Could not determine API key parameters.")
+
+    # 构建目标 URL
+    # 假设原始请求的 path 已经包含了完整的后端服务 URL，例如 /v1/https/open.bigmodel.cn/api/paas/v4/chat/completions
+    # 我们需要提取出 https://open.bigmodel.cn/api/paas/v4/chat/completions
+    match = re.match(r"/v1/(https?://.*)", path)
+    if not match:
+        logger.error(f"Invalid target URL format in path: {path}")
+        return create_error_response(400, "Invalid target URL format.")
+
+    full_target_url = match.group(1)
+
+    # 准备转发请求的头部和内容
+    headers = dict(request.headers)
+    headers.pop("host", None) # 移除 host 头，避免后端服务解析错误
+    headers.pop("authorization", None) # 移除原始的 authorization 头，我们将注入新的 API 密钥
+
+    # 注入 API 密钥
+    if api_type == "llm":
+        # 对于 LLM，通常 API 密钥在 Authorization 头中
+        headers["Authorization"] = f"Bearer {api_key}"
+    elif api_type == "search":
+        # 对于 Tavily 等搜索引擎，API 密钥可能在请求体中或自定义头中
+        # 这里假设 Tavily API 密钥在请求体中，需要修改请求体
+        # 注意：修改请求体需要重新构建请求，这可能比较复杂
+        # 更简单的做法是如果后端支持，通过自定义头传递
+        # 假设 Tavily API 密钥在请求体中，且请求体是 JSON
+        if request.method == "POST":
+            try:
+                request_body = await request.json()
+                request_body["api_key"] = api_key # 注入 Tavily API 密钥
+                request_content = json.dumps(request_body).encode("utf-8")
+                headers["Content-Type"] = "application/json"
+            except json.JSONDecodeError:
+                logger.error(f"Search request body is not valid JSON for path: {path}")
+                return create_error_response(400, "Search request body must be valid JSON.")
+        else:
+            # 如果是 GET 请求，API 密钥可能在查询参数中，这里需要根据实际情况调整
+            logger.warning(f"Search API key injection for GET request not implemented for path: {path}")
+            return create_error_response(501, "Search API key injection for GET requests is not yet supported.")
+
+    # 转发请求
+    try:
+        req = client.build_request(
+            method=request.method,
+            url=full_target_url,
+            headers=headers,
+            content=request_content if 'request_content' in locals() else await request.body(),
+            params=request.query_params,
+            timeout=30.0 # 设置超时时间
+        )
+
+        proxy_response = await client.send(req, stream=True)
+
+        return StreamingResponse(
+            proxy_response.aiter_bytes(),
+            status_code=proxy_response.status_code,
+            headers=proxy_response.headers
+        )
+    except httpx.RequestError as e:
+        logger.error(f"HTTPX Request Error for {full_target_url}: {e}")
+        return create_error_response(500, f"Proxy request failed: {e}")
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        return create_error_response(500, "An unexpected error occurred during proxying.")

proxy.py

@@ -39,6 +39,7 @@ async def do_proxy(url: str, method: str, headers: dict, content: str, max_retri
                 model_name = None
                 try:
                     content_json = json.loads(content)
+                    
                     model_name = content_json.get('model')
                     if model_name:
                         logger.info(f"从内容中提取的模型名称: {model_name}")
@@ -48,7 +49,7 @@ async def do_proxy(url: str, method: str, headers: dict, content: str, max_retri
                     logger.warning("内容不是有效的 JSON 格式，无法提取 'model' 键。")
                 except Exception as e:
                     logger.error(f"提取模型名称时发生错误: {str(e)}")
-
+                # api_key_info = await get_api_key_info('chat', model_name)
                 api_key_info = await get_api_key_info(model_name)
                 if not api_key_info:
                     return _create_error_response(status.HTTP_500_INTERNAL_SERVER_ERROR, "无法获取API密钥信息", "APIKeyError")
@@ -108,5 +109,6 @@ async def do_proxy(url: str, method: str, headers: dict, content: str, max_retri
         return _create_error_response(e.status_code, e.detail, "HTTPException")
 
     except Exception as e:
+        print('请检查当前是否运行在本机开发环境')
         logger.error(f"🔥 致命错误: {type(e).__name__}: {str(e)}")
         return _create_error_response(status.HTTP_500_INTERNAL_SERVER_ERROR, f"内部服务器错误: {str(e)}", "InternalServerError")