Download agy2api/src/converter/antigravity_fix.py from a3216/ds2api: direct link, hf CLI and curl.
- Browser
- Download file 37.6 kB
-
https://huggingface.co/spaces/a3216/ds2api/resolve/main/agy2api/src/converter/antigravity_fix.py
- Command line
-
hf download hf://spaces/a3216/ds2api/agy2api/src/converter/antigravity_fix.py
-
curl -L -o antigravity_fix.py https://huggingface.co/spaces/a3216/ds2api/resolve/main/agy2api/src/converter/antigravity_fix.py
37.6 kB
| """ | |
| Antigravity Format Utilities - 独立的 Antigravity 请求处理和转换工具 | |
| 设计要点: | |
| * 每个模型家族在 resolve_profile 里有独立的一行配置 (后端模型 ID / 思考方式) | |
| * 所有模型禁用预填充 (profile.no_prefill 恒为 True) | |
| * 不修改调用方传入的 request (generationConfig / thinkingConfig / contents 均先复制) | |
| ──────────────────────────────────────────────────────────────── | |
| 按项目要求: | |
| - 使用 print 输出 warning/error,去掉 debug 日志 | |
| """ | |
| import json | |
| import re | |
| import uuid | |
| from dataclasses import dataclass | |
| from typing import Any, Dict, List, Optional, Tuple | |
| from config import ( | |
| apply_sensitive_word_filter, | |
| get_model_rewrite_filter, | |
| get_return_thoughts_to_frontend, | |
| get_sensitive_word_filter, | |
| rewrite_model_name, | |
| ) | |
| from src.converter.thoughtSignature_fix import SKIP_THOUGHT_SIGNATURE_VALIDATOR | |
| # ==================== 常量配置 ==================== | |
| # 图片生成基础模型名(上游变更时仅需改这里) | |
| IMAGE_BASE_MODEL = "gemini-3.1-flash-image" | |
| # 图片生成支持的宽高比 | |
| SUPPORTED_ASPECT_RATIOS = [ | |
| (1, 1), (2, 3), (3, 2), (3, 4), (4, 3), | |
| (4, 5), (5, 4), (9, 16), (16, 9), (21, 9), | |
| ] | |
| # ==================== Gemini API 安全配置 ==================== | |
| DEFAULT_SAFETY_SETTINGS = [ | |
| {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "OFF"}, | |
| {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "OFF"}, | |
| {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "OFF"}, | |
| {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "OFF"}, | |
| {"category": "HARM_CATEGORY_CIVIC_INTEGRITY", "threshold": "OFF"}, | |
| {"category": "HARM_CATEGORY_IMAGE_HATE", "threshold": "OFF"}, | |
| {"category": "HARM_CATEGORY_IMAGE_DANGEROUS_CONTENT", "threshold": "OFF"}, | |
| {"category": "HARM_CATEGORY_IMAGE_HARASSMENT", "threshold": "OFF"}, | |
| {"category": "HARM_CATEGORY_IMAGE_SEXUALLY_EXPLICIT", "threshold": "OFF"}, | |
| {"category": "HARM_CATEGORY_JAILBREAK", "threshold": "OFF"}, | |
| ] | |
| MAX_OUTPUT_TOKENS = 64000 | |
| TOP_K = 64 | |
| _CLAUDE_THINKING_SIGNATURE = "skip_thought_signature_validator" # 官方文档推荐的虚拟签名 | |
| def _append_schema_hint(schema: Dict[str, Any], hint: str) -> None: | |
| """Move fragile validation details into description instead of sending them raw.""" | |
| if not hint: | |
| return | |
| desc = schema.get("description") | |
| schema["description"] = f"{desc} ({hint})" if desc else hint | |
| def _resolve_schema_ref(ref: str, root_schema: Dict[str, Any]) -> Optional[Dict[str, Any]]: | |
| if not isinstance(ref, str) or not ref.startswith("#/"): | |
| return None | |
| node: Any = root_schema | |
| for part in ref[2:].split("/"): | |
| part = part.replace("~1", "/").replace("~0", "~") | |
| if not isinstance(node, dict) or part not in node: | |
| return None | |
| node = node[part] | |
| return node if isinstance(node, dict) else None | |
| def _clean_parameters_json_schema( | |
| schema: Any, | |
| root_schema: Optional[Dict[str, Any]] = None, | |
| visited: Optional[set] = None, | |
| ) -> Any: | |
| """Clean a tool schema for Code Assist's parametersJsonSchema field.""" | |
| if isinstance(schema, list): | |
| return [_clean_parameters_json_schema(item, root_schema, visited) for item in schema] | |
| if not isinstance(schema, dict): | |
| return schema | |
| if root_schema is None: | |
| root_schema = schema | |
| if visited is None: | |
| visited = set() | |
| schema_id = id(schema) | |
| if schema_id in visited: | |
| return {"type": "object", "description": "circular reference"} | |
| visited.add(schema_id) | |
| ref_key = "$ref" if "$ref" in schema else ("ref" if "ref" in schema else None) | |
| if ref_key: | |
| resolved = _resolve_schema_ref(schema[ref_key], root_schema) | |
| if resolved: | |
| merged = dict(resolved) | |
| for key in ("description", "default"): | |
| if key in schema: | |
| merged[key] = schema[key] | |
| schema = merged | |
| if "allOf" in schema: | |
| result: Dict[str, Any] = {} | |
| for item in schema.get("allOf") or []: | |
| cleaned_item = _clean_parameters_json_schema(item, root_schema, visited) | |
| if not isinstance(cleaned_item, dict): | |
| continue | |
| if "properties" in cleaned_item: | |
| result.setdefault("properties", {}).update(cleaned_item["properties"]) | |
| if "required" in cleaned_item: | |
| result.setdefault("required", []).extend(cleaned_item["required"]) | |
| for key, value in cleaned_item.items(): | |
| if key not in ("properties", "required"): | |
| result[key] = value | |
| for key, value in schema.items(): | |
| if key not in ("allOf", "properties", "required"): | |
| result[key] = value | |
| elif key in ("properties", "required") and key not in result: | |
| result[key] = value | |
| else: | |
| result = dict(schema) | |
| if result.get("nullable") is True: | |
| _append_schema_hint(result, "nullable") | |
| if "type" in result: | |
| type_value = result["type"] | |
| if isinstance(type_value, list): | |
| non_null_types = [ | |
| str(t).lower() | |
| for t in type_value | |
| if isinstance(t, str) and t.lower() != "null" | |
| ] | |
| if non_null_types: | |
| result["type"] = non_null_types[0] | |
| if any(str(t).lower() == "null" for t in type_value): | |
| _append_schema_hint(result, "nullable") | |
| else: | |
| result["type"] = "string" | |
| elif isinstance(type_value, str): | |
| lower_type = type_value.lower() | |
| if lower_type in {"string", "number", "integer", "boolean", "array", "object"}: | |
| result["type"] = lower_type | |
| elif lower_type == "null": | |
| result["type"] = "string" | |
| _append_schema_hint(result, "nullable") | |
| else: | |
| result.pop("type", None) | |
| if "anyOf" in result or "oneOf" in result: | |
| union_key = "anyOf" if "anyOf" in result else "oneOf" | |
| union_items = result.get(union_key) or [] | |
| cleaned_items = [ | |
| item for item in ( | |
| _clean_parameters_json_schema(item, root_schema, visited) | |
| for item in union_items | |
| ) | |
| if isinstance(item, dict) | |
| ] | |
| enum_values = [ | |
| item.get("const") | |
| for item in union_items | |
| if isinstance(item, dict) and item.get("const") not in ("", None) | |
| ] | |
| if enum_values and len(enum_values) == len(union_items): | |
| result["type"] = "string" | |
| result["enum"] = [str(v) for v in enum_values] | |
| else: | |
| preferred = next( | |
| ( | |
| item for item in cleaned_items | |
| if item.get("type") in ("object", "array") or item.get("properties") | |
| ), | |
| None, | |
| ) | |
| if preferred is None: | |
| preferred = next((item for item in cleaned_items if item.get("type") or item.get("enum")), None) | |
| if preferred: | |
| original_description = result.get("description") | |
| result.update(preferred) | |
| if original_description: | |
| _append_schema_hint(result, original_description) | |
| result.pop("anyOf", None) | |
| result.pop("oneOf", None) | |
| if result.get("type") == "array": | |
| items = result.get("items") | |
| if isinstance(items, list): | |
| if items: | |
| result["items"] = _clean_parameters_json_schema(items[0], root_schema, visited) | |
| _append_schema_hint(result, "tuple schema simplified") | |
| else: | |
| result.pop("items", None) | |
| elif isinstance(items, dict): | |
| result["items"] = _clean_parameters_json_schema(items, root_schema, visited) | |
| validation_keys = { | |
| "default", "minLength", "maxLength", "minimum", "maximum", | |
| "minItems", "maxItems", "pattern", "format", "uniqueItems", | |
| } | |
| for key in list(result.keys()): | |
| if key in validation_keys: | |
| value = result.pop(key) | |
| if value not in (None, "", {}, []): | |
| _append_schema_hint(result, f"{key}: {json.dumps(value, ensure_ascii=False)}") | |
| unsupported_keys = { | |
| "title", "$schema", "$id", "$ref", "ref", "strict", "nullable", | |
| "exclusiveMaximum", "exclusiveMinimum", "additionalProperties", | |
| "allOf", "anyOf", "oneOf", "$defs", "definitions", "example", | |
| "examples", "readOnly", "writeOnly", "const", "additionalItems", | |
| "contains", "patternProperties", "dependencies", "propertyNames", | |
| "if", "then", "else", "contentEncoding", "contentMediaType", | |
| } | |
| for key in list(result.keys()): | |
| if key in unsupported_keys or key.startswith("x-"): | |
| del result[key] | |
| if isinstance(result.get("properties"), dict): | |
| result["properties"] = { | |
| prop_name: _clean_parameters_json_schema(prop_schema, root_schema, visited) | |
| for prop_name, prop_schema in result["properties"].items() | |
| } | |
| if "properties" in result and "type" not in result: | |
| result["type"] = "object" | |
| # required 仅约束字段必须出现,null 也是合法取值;nullable 不等于可选。 | |
| # 若把 nullable 属性(如 Pydantic v2 的 type: ["string", "null"])从 required | |
| # 中剔除,上游 Gemini 会认为所有参数都非必填,频繁生成空参数 {} 的工具调用, | |
| # 因此保留原始接口契约中的 required 约束。 | |
| if isinstance(result.get("required"), list): | |
| prop_names = set(result.get("properties", {}).keys()) if isinstance(result.get("properties"), dict) else None | |
| required = [] | |
| for item in result["required"]: | |
| if not isinstance(item, str): | |
| continue | |
| if prop_names is not None and item not in prop_names: | |
| continue | |
| if item not in required: | |
| required.append(item) | |
| if required: | |
| result["required"] = required | |
| else: | |
| result.pop("required", None) | |
| return result | |
| def _normalize_tools_for_internal_api(tools: Any) -> Any: | |
| if not isinstance(tools, list): | |
| return tools | |
| normalized_tools = [] | |
| for tool in tools: | |
| if not isinstance(tool, dict): | |
| normalized_tools.append(tool) | |
| continue | |
| normalized_tool = tool.copy() | |
| declarations = normalized_tool.get("functionDeclarations") | |
| if declarations is None: | |
| declarations = normalized_tool.get("function_declarations") | |
| if isinstance(declarations, list): | |
| normalized_declarations = [] | |
| for declaration in declarations: | |
| if not isinstance(declaration, dict): | |
| normalized_declarations.append(declaration) | |
| continue | |
| normalized_declaration = declaration.copy() | |
| if "parametersJsonSchema" in normalized_declaration: | |
| schema = normalized_declaration["parametersJsonSchema"] | |
| elif "parameters_json_schema" in normalized_declaration: | |
| schema = normalized_declaration.pop("parameters_json_schema", None) | |
| else: | |
| schema = normalized_declaration.pop("parameters", None) | |
| normalized_declaration.pop("parameters", None) | |
| normalized_declaration.pop("parameters_json_schema", None) | |
| if schema not in (None, {}, []): | |
| normalized_declaration["parametersJsonSchema"] = _clean_parameters_json_schema(schema) | |
| else: | |
| normalized_declaration.pop("parametersJsonSchema", None) | |
| normalized_declarations.append(normalized_declaration) | |
| normalized_tool.pop("function_declarations", None) | |
| normalized_tool["functionDeclarations"] = normalized_declarations | |
| normalized_tools.append(normalized_tool) | |
| return normalized_tools | |
| def _ensure_empty_tool_schema_for_claude(tools: Any, model_name: str) -> Any: | |
| if not isinstance(tools, list): | |
| return tools | |
| is_claude = "claude" in (model_name or "").lower() | |
| if is_claude: | |
| normalized_tools = [] | |
| for tool in tools: | |
| if not isinstance(tool, dict): | |
| normalized_tools.append(tool) | |
| continue | |
| normalized_tool = tool.copy() | |
| schema = {"type": "object", "properties": {}} | |
| name = "" | |
| description = "" | |
| # Extract schema from either format | |
| custom_tool = normalized_tool.get("custom") | |
| if isinstance(custom_tool, dict): | |
| schema = custom_tool.get("input_schema") or custom_tool.get("inputSchema") or schema | |
| name = custom_tool.get("name", "") | |
| description = custom_tool.get("description", "") | |
| else: | |
| declarations = normalized_tool.get("functionDeclarations") or normalized_tool.get("function_declarations") | |
| if isinstance(declarations, list) and declarations and isinstance(declarations[0], dict): | |
| decl = declarations[0] | |
| schema = ( | |
| decl.get("parametersJsonSchema") or | |
| decl.get("parameters_json_schema") or | |
| decl.get("parameters") or schema | |
| ) | |
| name = decl.get("name", "") | |
| description = decl.get("description", "") | |
| # For ALL Claude models, try outputting functionDeclarations with parameters! | |
| # If Google's backend expects parameters to translate to input_schema, this will fix the Field required error. | |
| normalized_tools.append({ | |
| "functionDeclarations": [{ | |
| "name": name, | |
| "description": description, | |
| "parameters": schema | |
| }] | |
| }) | |
| return normalized_tools | |
| # 对于 Gemini 模型: | |
| # 后端需要标准的 functionDeclarations 格式。 | |
| # 并且,必须只能使用 "parameters" 字段,如果使用了 "parametersJsonSchema", | |
| # 会报 "parameters_json_schema must not be set when parameters is set" 等冲突错误 | |
| normalized_tools = [] | |
| for tool in tools: | |
| if not isinstance(tool, dict): | |
| normalized_tools.append(tool) | |
| continue | |
| normalized_tool = tool.copy() | |
| # 1. 如果包含 Anthropic 原生的 "custom" 工具格式,将其转换为 Gemini 的 functionDeclarations 格式 | |
| custom_tool = normalized_tool.get("custom") | |
| if isinstance(custom_tool, dict): | |
| schema = custom_tool.get("input_schema") or custom_tool.get("inputSchema") | |
| if schema in (None, {}, []): | |
| schema = {"type": "object", "properties": {}} | |
| declaration = { | |
| "name": custom_tool.get("name", ""), | |
| "description": custom_tool.get("description", ""), | |
| "parameters": schema | |
| } | |
| normalized_tools.append({ | |
| "functionDeclarations": [declaration] | |
| }) | |
| continue | |
| # 2. 如果包含标准的 functionDeclarations 格式,确保参数不为空且只使用 parameters 字段 | |
| declarations = normalized_tool.get("functionDeclarations") or normalized_tool.get("function_declarations") | |
| if isinstance(declarations, list): | |
| normalized_declarations = [] | |
| for declaration in declarations: | |
| if not isinstance(declaration, dict): | |
| normalized_declarations.append(declaration) | |
| continue | |
| normalized_declaration = declaration.copy() | |
| # 兼容不同字段格式并归一化到 parameters | |
| schema = ( | |
| normalized_declaration.get("parameters") | |
| or normalized_declaration.get("parametersJsonSchema") | |
| or normalized_declaration.get("parameters_json_schema") | |
| ) | |
| if schema in (None, {}, []): | |
| schema = {"type": "object", "properties": {}} | |
| # 只保留 parameters 字段,防止与 parametersJsonSchema 冲突 | |
| normalized_declaration["parameters"] = schema | |
| normalized_declaration.pop("parametersJsonSchema", None) | |
| normalized_declaration.pop("parameters_json_schema", None) | |
| normalized_declarations.append(normalized_declaration) | |
| normalized_tool.pop("function_declarations", None) | |
| normalized_tool["functionDeclarations"] = normalized_declarations | |
| normalized_tools.append(normalized_tool) | |
| return normalized_tools | |
| def _should_skip_thought_signature(part: Dict[str, Any], model_name: str) -> bool: | |
| if "claude" in (model_name or "").lower(): | |
| return False | |
| return ( | |
| "functionCall" in part | |
| or "function_call" in part | |
| or part.get("thought") is True | |
| or "thoughtSignature" in part | |
| or "thought_signature" in part | |
| ) | |
| def _normalize_part_thought_signature(part: Dict[str, Any], model_name: str) -> Dict[str, Any]: | |
| normalized = part.copy() | |
| if _should_skip_thought_signature(normalized, model_name): | |
| normalized.pop("thought_signature", None) | |
| normalized["thoughtSignature"] = SKIP_THOUGHT_SIGNATURE_VALIDATOR | |
| return normalized | |
| def _ensure_tool_call_ids(contents: Any, model_name: str) -> Any: | |
| """ | |
| 确保 functionCall/functionResponse 携带 id 字段 (仅 Claude)。 | |
| Antigravity 后端在目标模型为 Claude 时,会将 Gemini 的 | |
| functionCall/functionResponse 内部转换为 Anthropic 的 | |
| tool_use/tool_result,而后者的 id 是必填字段。原生 Gemini 请求 | |
| 可能不带 id,因此这里按 name 补全缺失的 id,保证同一次调用的 | |
| functionCall 与 functionResponse 使用相同 id。不修改入参。 | |
| """ | |
| if "claude" not in (model_name or "").lower(): | |
| return contents | |
| if not isinstance(contents, list): | |
| return contents | |
| pending_ids_by_name: Dict[str, list] = {} | |
| result = [] | |
| for content in contents: | |
| if not isinstance(content, dict) or not isinstance(content.get("parts"), list): | |
| result.append(content) | |
| continue | |
| new_parts = [] | |
| for part in content["parts"]: | |
| if isinstance(part, dict): | |
| fc = part.get("functionCall") | |
| fr = part.get("functionResponse") | |
| if isinstance(fc, dict): | |
| if not fc.get("id"): | |
| fc = {**fc, "id": f"toolu_{uuid.uuid4().hex}"} | |
| part = {**part, "functionCall": fc} | |
| pending_ids_by_name.setdefault(fc.get("name"), []).append(fc["id"]) | |
| elif isinstance(fr, dict): | |
| queue = pending_ids_by_name.get(fr.get("name")) or [] | |
| if fr.get("id"): | |
| if fr["id"] in queue: | |
| queue.remove(fr["id"]) | |
| else: | |
| new_id = queue.pop(0) if queue else f"toolu_{uuid.uuid4().hex}" | |
| part = {**part, "functionResponse": {**fr, "id": new_id}} | |
| new_parts.append(part) | |
| result.append({**content, "parts": new_parts}) | |
| return result | |
| def _parse_size_to_image_config(size_str: str) -> Dict[str, str]: | |
| """ | |
| 解析用户传入的 size 参数为 Gemini imageConfig 参数 | |
| 支持格式: "1024x1536", "1024*1536", "1024X1536" | |
| Returns: | |
| 包含 aspectRatio 和/或 imageSize 的字典 | |
| """ | |
| config = {} | |
| size_str = size_str.strip() | |
| match = re.match(r"^(\d+)\s*[xX*×]\s*(\d+)$", size_str) | |
| if not match: | |
| return config | |
| width, height = int(match.group(1)), int(match.group(2)) | |
| if width <= 0 or height <= 0: | |
| return config | |
| # 计算最接近的支持宽高比 | |
| target_ratio = width / height | |
| best_ratio = None | |
| best_diff = float("inf") | |
| for w, h in SUPPORTED_ASPECT_RATIOS: | |
| diff = abs(target_ratio - w / h) | |
| if diff < best_diff: | |
| best_diff = diff | |
| best_ratio = f"{w}:{h}" | |
| if best_ratio: | |
| config["aspectRatio"] = best_ratio | |
| # 根据最大边长确定 imageSize(使用最接近的档位) | |
| max_dim = max(width, height) | |
| if max_dim <= 1280: | |
| config["imageSize"] = "1K" | |
| elif max_dim <= 2560: | |
| config["imageSize"] = "2K" | |
| else: | |
| config["imageSize"] = "4K" | |
| return config | |
| def prepare_image_generation_request( | |
| request_body: Dict[str, Any], | |
| model: str | |
| ) -> Dict[str, Any]: | |
| """ | |
| 图像生成模型请求体后处理 | |
| 支持三种方式指定图片参数(优先级从高到低): | |
| 1. size 参数: 如 "1024x1536",自动计算 aspectRatio 和 imageSize | |
| 2. 模型名后缀: 如 -4k, -2k, -16x9, -1x1 | |
| 3. 默认值: 不设置额外参数 | |
| """ | |
| request_body = request_body.copy() | |
| model_lower = model.lower() | |
| # 优先使用 size 参数 | |
| size_str = request_body.pop("size", None) | |
| if size_str: | |
| image_config = _parse_size_to_image_config(size_str) | |
| else: | |
| # 从模型名后缀解析 | |
| image_size = "4K" if "-4k" in model_lower else "2K" if "-2k" in model_lower else None | |
| aspect_ratio = None | |
| for suffix, ratio in [ | |
| ("-21x9", "21:9"), ("-16x9", "16:9"), ("-9x16", "9:16"), | |
| ("-4x3", "4:3"), ("-3x4", "3:4"), ("-1x1", "1:1") | |
| ]: | |
| if suffix in model_lower: | |
| aspect_ratio = ratio | |
| break | |
| image_config = {} | |
| if aspect_ratio: | |
| image_config["aspectRatio"] = aspect_ratio | |
| if image_size: | |
| image_config["imageSize"] = image_size | |
| request_body["model"] = IMAGE_BASE_MODEL # 统一使用基础模型名 | |
| request_body["generationConfig"] = { | |
| "candidateCount": 1, | |
| "imageConfig": image_config | |
| } | |
| # 移除不需要的字段 | |
| for key in ("systemInstruction", "tools", "toolConfig"): | |
| request_body.pop(key, None) | |
| return request_body | |
| # ==================== 模型配置 (关键词匹配) ==================== | |
| class ModelProfile: | |
| family: str # "gemini4" | "gemini3" | "claude" | "image" | "other" | |
| upstream: str # 实际发给 Antigravity 后端的模型 ID | |
| thinking: str = "none" # "route" | "budget" | "none",见 _apply_thinking | |
| thinking_budget: int = 1024 # 仅 thinking == "budget" 时使用 | |
| no_prefill: bool = True # 所有模型禁用预填充 | |
| # 精确别名: 客户端模型名 -> 后端真实 ID | |
| _UPSTREAM_ALIASES: Dict[str, str] = { | |
| # gemini-3.1-pro-* 已从上游模型列表下线,别名已删除 | |
| } | |
| async def _get_model_rewrite_rules(): | |
| """读取生效的模型名复写规则;未启用时返回 None""" | |
| enabled, rules = await get_model_rewrite_filter() | |
| return rules if enabled and rules else None | |
| def resolve_profile(model: str) -> ModelProfile: | |
| """ | |
| 按关键词匹配模型,自上而下第一个命中的规则生效: | |
| image 图片生成,走独立路径 | |
| claude-opus-5-5 / claude-sonnet-5-5 思考强度由模型 ID 后缀决定,原样透传 | |
| claude-opus-4-6 映射到 claude-opus-4-6-thinking | |
| claude-sonnet-4-6-thinking 映射到 claude-sonnet-4-6 | |
| claude (其他) 原样透传 | |
| gemini-4* (如 gemini-4-argon-low/-medium/-high) 思考深度由模型 ID 后缀决定,原样透传 | |
| gemini-3* / *-agent 思考深度由模型 ID (-low/-medium/-high/-tiered/-extra-low) 决定 | |
| 其他 名字含 think 才发 thinkingBudget,原样透传 | |
| """ | |
| model = model or "" | |
| lower = model.lower() | |
| think = "budget" if "think" in lower else "none" | |
| if "image" in lower: | |
| return ModelProfile("image", model) | |
| if "claude" in lower: | |
| # Opus 5.5 / Sonnet 5.5: 思考强度由模型 ID 后缀 (-low/-high 等) 决定,原样透传 | |
| normalized = lower.replace(".", "-") | |
| if "claude-opus-5-5" in normalized or "claude-sonnet-5-5" in normalized: | |
| return ModelProfile("claude", model, "route") | |
| upstream = model | |
| if "claude-opus-4-6" in lower: | |
| upstream = "claude-opus-4-6-thinking" | |
| elif "claude-sonnet-4-6-thinking" in lower: | |
| upstream = "claude-sonnet-4-6" | |
| return ModelProfile("claude", upstream, think) | |
| if "gemini-4" in lower: | |
| return ModelProfile("gemini4", _UPSTREAM_ALIASES.get(lower, model), "route") | |
| if "gemini-3" in lower or lower.endswith("-agent"): | |
| return ModelProfile("gemini3", _UPSTREAM_ALIASES.get(lower, model), "route") | |
| return ModelProfile("other", model, think) | |
| # ==================== 模型特性辅助函数 ==================== | |
| def is_thinking_model(model_name: str) -> bool: | |
| """检查是否为思考模型 (模型名包含 think,仅为兼容保留)""" | |
| return "think" in model_name.lower() | |
| def _apply_thinking(profile: ModelProfile, generation_config: Dict[str, Any], return_thoughts: bool) -> None: | |
| """按模型 profile 写入 thinkingConfig (就地修改 generation_config,thinkingConfig 先复制)""" | |
| if profile.thinking == "none": | |
| return | |
| thinking_config = dict(generation_config.get("thinkingConfig") or {}) | |
| thinking_config.pop("thinkingLevel", None) | |
| if profile.thinking == "route": | |
| # 思考深度由模型 ID 决定,level/budget 会与之冲突 | |
| thinking_config.pop("thinkingBudget", None) | |
| else: # "budget" | |
| thinking_config["thinkingBudget"] = profile.thinking_budget | |
| thinking_config["includeThoughts"] = return_thoughts | |
| generation_config["thinkingConfig"] = thinking_config | |
| # ==================== contents 处理 ==================== | |
| async def _get_sensitive_word_patterns(): | |
| """读取生效的敏感词正则列表;未启用时返回 None(避免无谓的配置读取开销为 0 时的开销可忽略)""" | |
| enabled, patterns = await get_sensitive_word_filter() | |
| return patterns if enabled and patterns else None | |
| def _filter_text(text: str, patterns) -> str: | |
| """对文本应用敏感词过滤(大小写不敏感,命中替换为空)""" | |
| return apply_sensitive_word_filter(text, patterns) | |
| def _filter_contents_sensitive_words(contents: Any, patterns) -> Any: | |
| """对 contents 内所有 text part 应用敏感词过滤(不修改入参)""" | |
| if not isinstance(contents, list): | |
| return contents | |
| new_contents = [] | |
| for content in contents: | |
| if not (isinstance(content, dict) and isinstance(content.get("parts"), list)): | |
| new_contents.append(content) | |
| continue | |
| new_parts = [] | |
| for part in content["parts"]: | |
| if ( | |
| isinstance(part, dict) | |
| and isinstance(part.get("text"), str) | |
| and part["text"] | |
| ): | |
| filtered = _filter_text(part["text"], patterns) | |
| if filtered != part["text"]: | |
| part = {**part, "text": filtered} | |
| new_parts.append(part) | |
| new_contents.append({**content, "parts": new_parts}) | |
| return new_contents | |
| def _filter_system_instruction_sensitive_words(system_instruction: Any, patterns) -> Any: | |
| """对 systemInstruction 的 text part 应用敏感词过滤(不修改入参)""" | |
| if not (isinstance(system_instruction, dict) and isinstance(system_instruction.get("parts"), list)): | |
| return system_instruction | |
| new_parts = [] | |
| for part in system_instruction["parts"]: | |
| if ( | |
| isinstance(part, dict) | |
| and isinstance(part.get("text"), str) | |
| and part["text"] | |
| ): | |
| filtered = _filter_text(part["text"], patterns) | |
| if filtered != part["text"]: | |
| part = {**part, "text": filtered} | |
| new_parts.append(part) | |
| return {**system_instruction, "parts": new_parts} | |
| def _clean_contents(contents: List[Any], model_name: str) -> List[Any]: | |
| """过滤空 part、规范 thoughtSignature、修正 text 字段类型、丢弃没有有效 part 的 content""" | |
| cleaned_contents = [] | |
| for content in contents: | |
| if not (isinstance(content, dict) and "parts" in content): | |
| cleaned_contents.append(content) | |
| continue | |
| valid_parts = [] | |
| for part in content["parts"]: | |
| if not isinstance(part, dict): | |
| continue | |
| # 必须先归一化 text(rstrip 可能把 "\n" 之类削成 "")再做有效性校验, | |
| # 否则纯空白 text 先通过校验、后变空串,发给上游会转成缺少 text 字段的 | |
| # text 块(Claude 报 messages.N.content.M.text.text: Field required) | |
| if "text" in part: | |
| part = part.copy() # copy-on-write,避免原地修改调用方的 contents | |
| text_value = part["text"] | |
| if isinstance(text_value, list): | |
| # 元素可能是 {"type":"text","text":"..."},不能直接 str(dict),否则会污染 model 历史 | |
| print(f"[ANTIGRAVITY_FIX] text 字段是列表,自动合并: {text_value}", flush=True) | |
| text_parts = [] | |
| for t in text_value: | |
| if isinstance(t, dict) and "text" in t: | |
| text_parts.append(str(t["text"])) | |
| elif isinstance(t, str): | |
| text_parts.append(t) | |
| elif t is not None: | |
| text_parts.append(str(t)) | |
| part["text"] = " ".join(text_parts) | |
| elif isinstance(text_value, str): | |
| part["text"] = text_value.rstrip() | |
| else: | |
| print(f"[ANTIGRAVITY_FIX] text 字段类型异常 ({type(text_value)}), 转为字符串: {text_value}", flush=True) | |
| part["text"] = str(text_value) | |
| if part["text"] == "": | |
| # part 还有其他有效字段(如 functionCall)时仅去掉 text 字段 | |
| part.pop("text", None) | |
| # thought 字段可以为空,其余字段至少要有一个非空值 | |
| has_valid_value = any( | |
| value not in (None, "", {}, []) | |
| for key, value in part.items() | |
| if key != "thought" | |
| ) | |
| if not has_valid_value: | |
| print(f"[ANTIGRAVITY_FIX] 移除空的或无效的 part: {part}", flush=True) | |
| continue | |
| part = _normalize_part_thought_signature(part, model_name) | |
| valid_parts.append(part) | |
| if valid_parts: | |
| cleaned_content = content.copy() | |
| cleaned_content["parts"] = valid_parts | |
| cleaned_contents.append(cleaned_content) | |
| else: | |
| print(f"[ANTIGRAVITY_FIX] 跳过没有有效 parts 的 content: {content.get('role')}", flush=True) | |
| return cleaned_contents | |
| def _strip_trailing_model_turns(contents: List[Any]) -> Tuple[List[Any], int]: | |
| """循环移除末尾的 model 消息,保证以用户消息结尾""" | |
| contents = list(contents) | |
| removed = 0 | |
| while contents and isinstance(contents[-1], dict) and contents[-1].get("role") == "model": | |
| contents.pop() | |
| removed += 1 | |
| return contents, removed | |
| def _prepare_claude_history(contents: List[Any], generation_config: Dict[str, Any]) -> List[Any]: | |
| """ | |
| Claude 专属历史处理: | |
| - 含工具调用 (MCP 场景): 移除 thinkingConfig,避免失效 | |
| - 否则: 给最后一条 model 消息补一个 thinking 块 (虚拟签名跳过验证) | |
| """ | |
| has_tool_calls = any( | |
| isinstance(content, dict) | |
| and any( | |
| isinstance(part, dict) and ("functionCall" in part or "function_call" in part) | |
| for part in content.get("parts", []) or [] | |
| ) | |
| for content in contents | |
| ) | |
| if has_tool_calls: | |
| print("[ANTIGRAVITY] 检测到工具调用(MCP场景),移除 thinkingConfig 避免失效", flush=True) | |
| generation_config.pop("thinkingConfig", None) | |
| return contents | |
| contents = list(contents) | |
| for i in range(len(contents) - 1, -1, -1): | |
| content = contents[i] | |
| if isinstance(content, dict) and content.get("role") == "model": | |
| parts = content.get("parts", []) or [] | |
| first = parts[0] if parts else None | |
| if not (isinstance(first, dict) and ("thought" in first or "thoughtSignature" in first)): | |
| thinking_part = {"text": "...", "thoughtSignature": _CLAUDE_THINKING_SIGNATURE} | |
| contents[i] = {**content, "parts": [thinking_part] + list(parts)} | |
| break | |
| return contents | |
| # ==================== 统一的 Antigravity 请求后处理 ==================== | |
| async def normalize_antigravity_request( | |
| request: Dict[str, Any], | |
| ) -> Dict[str, Any]: | |
| """ | |
| 规范化 Antigravity 请求 | |
| 处理逻辑: | |
| 0. 敏感词过滤(contents / systemInstruction,面板可配,热更新) | |
| 0.5 模型名复写(面板可配,热更新,支持正则与反向引用) | |
| 1. 按模型名取 profile (关键词匹配) | |
| 2. 图片模型走独立路径 | |
| 3. 模型映射 + thinkingConfig (按 profile.thinking) | |
| 4. contents 清理 -> 预填充处理 -> Claude 专属处理 -> 工具调用 id | |
| 5. 工具 schema 规范化 | |
| 6. 公共参数 (safetySettings / maxOutputTokens / topK) | |
| Args: | |
| request: 原始请求字典 (不会被修改) | |
| Returns: | |
| 规范化后的请求 | |
| """ | |
| result = request.copy() | |
| model = result.get("model", "") | |
| generation_config = (result.get("generationConfig") or {}).copy() | |
| return_thoughts = await get_return_thoughts_to_frontend() | |
| # ========== 0.5 模型名复写(面板可配,热更新) ========== | |
| # 在抗截断前缀剥离之后、profile 解析之前应用: | |
| # 命中规则的模型名被替换为规则指定的模型名(支持正则与反向引用) | |
| rewrite_rules = await _get_model_rewrite_rules() | |
| if rewrite_rules and model: | |
| rewritten = rewrite_model_name(model, rewrite_rules) | |
| if rewritten != model: | |
| result["model"] = rewritten | |
| print(f"[ANTIGRAVITY] 模型名复写: {model} -> {rewritten}", flush=True) | |
| model = rewritten | |
| profile = resolve_profile(model) | |
| # ========== 0. 敏感词过滤 ========== | |
| # 在所有内容处理之前应用:命中面板配置的敏感词(大小写不敏感)直接替换为空, | |
| # 避免触发 Google API 端点的敏感词拦截 | |
| sensitive_patterns = await _get_sensitive_word_patterns() | |
| if sensitive_patterns: | |
| if isinstance(result.get("contents"), list): | |
| result["contents"] = _filter_contents_sensitive_words(result["contents"], sensitive_patterns) | |
| if result.get("systemInstruction") is not None: | |
| result["systemInstruction"] = _filter_system_instruction_sensitive_words( | |
| result.get("systemInstruction"), sensitive_patterns | |
| ) | |
| if result.get("system_instruction") is not None: | |
| result["system_instruction"] = _filter_system_instruction_sensitive_words( | |
| result.get("system_instruction"), sensitive_patterns | |
| ) | |
| # 图片模型走独立的图片生成处理路径 | |
| if profile.family == "image": | |
| return prepare_image_generation_request(result, model) | |
| upstream = profile.upstream | |
| result["model"] = upstream | |
| # ========== 1. 思考设置 ========== | |
| _apply_thinking(profile, generation_config, return_thoughts) | |
| # ========== 2. contents ========== | |
| if "contents" in result: | |
| contents = _clean_contents(result["contents"], upstream) | |
| if profile.no_prefill: | |
| contents, removed = _strip_trailing_model_turns(contents) | |
| if removed: | |
| print(f"[ANTIGRAVITY] {upstream} 禁用预填充,移除了 {removed} 条末尾 model 消息", flush=True) | |
| if profile.family == "claude": | |
| contents = _prepare_claude_history(contents, generation_config) | |
| result["contents"] = _ensure_tool_call_ids(contents, upstream) | |
| # ========== 3. 工具 ========== | |
| if "tools" in result: | |
| tools = _normalize_tools_for_internal_api(result.get("tools")) | |
| # Claude: functionDeclarations + parameters;Gemini: 只保留 parameters,避免与 parametersJsonSchema 冲突 | |
| result["tools"] = _ensure_empty_tool_schema_for_claude(tools, upstream) | |
| # ========== 公共处理 ========== | |
| generation_config.pop("presencePenalty", None) | |
| generation_config.pop("frequencyPenalty", None) | |
| generation_config.pop("stopSequences", None) | |
| result["safetySettings"] = DEFAULT_SAFETY_SETTINGS | |
| if generation_config: | |
| generation_config["maxOutputTokens"] = MAX_OUTPUT_TOKENS | |
| generation_config["topK"] = TOP_K | |
| result["generationConfig"] = generation_config | |
| return result |