ds2api / agy2api /src /converter /antigravity_fix.py
luckfun233
feat(agy): 内嵌 agy2api,接入 Gemini 模型与独立 AGY 面板
b0074f5
Raw History Blame Contribute Delete
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
# ==================== 模型配置 (关键词匹配) ====================
@dataclass(frozen=True)
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