Files
xiaoyin-gateway/app/adapters/openai_compat.py
T
api-gateway 0bf607e35f 第三十轮: 全面体检发现项全部修 —— 下载白名单/视频归属/会话落盘/i18n 收口/口令下限
老板对上一轮「只查未改」的体检清单回「全部」,逐项修完并直接上生产验证。

P0 产物下载白名单(实测复现的真 bug)
- Agnes 水印版产物走另一个 CDN(maas-watermark-prod-new.cn-wlcb.ufileos.com),
  download.allowed_hosts 只有普通版域名 → admin 老产物点「下载」必 400。
- 补域名;yaml + README 写明这张表是出网白名单、换 CDN 要同步维护。
- 生产实测:水印图下载 200 / 129871 bytes(改前 400);非白名单域名仍 400。

视频任务归属(新增 app/video_owners.py)
- GET /v1/videos/{id} 原先不判归属,任何登录账号拿到 id 就能读别人任务状态与产物 URL。
- 创建成功时登记 video_id→账号,轮询判权:他人 404(不用 403,避免 id 变存在性探针)、
  admin 放行、无登记的老任务放行(渐进收紧)。落盘 data/video_owners.json(600/TTL 7 天)。

登录会话落盘(app/sessions.py)
- 原先纯内存 → 每次重启全体被踢;现在 data/sessions.json:只存 token 的 sha256、
  原子写 + 600、写失败只告警、载入丢过期。吊销语义不变且吊销也落盘。
- 生产实测:登录拿 token → 重启 → 同一 token 仍 200;文件里不含明文 token。

口令下限 4→8(app/users.py)
- 只作用于「显式给密码/事后改密」;登录不判长度,既有短口令账号照常登。

/config/env 值校验
- 拒绝 \n / \r / \x00 与 >4096(带换行的值能在 .env 里凭空多出几行改掉别的变量)。
- 生产实测 400 且 md5(data/.env) 未变。

其它后端/一致性
- history 四个端点补 _offload(整份读写 ≤4MB,此前是唯一还在事件循环里同步跑的 IO)。
- /health/{provider} 注释更正:一直是 require_auth(恒定鉴权、不随 health_auth 放宽)。
- GET / 导航的 docs 一行改为仅在 docs_enabled 时列出;FastAPI 描述补 OpenCode Go。
- _req_headers 陈旧注释、_media_headers 与测速探针的「有意随机 session」注明。
- app/settings.py 备份写完显式 chmod 600(copy2 会照抄源的 644)。

前端 i18n 收口
- Videos 素材摘要 / lib/upload.ts 全部报错 / charts.ts 空态 → i18n(中英 737/737)。
- 删除 router.ts 中无人消费的 meta.title(只有中文的死元数据)。
- check-i18n.mjs 新增「硬编码中文」扫描(剥注释后扫字符串字面量,允许清单只放语言自称)。

文档 / 基建
- README:.env 补 OPENCODE_API_KEY、两层 .env 的 override 关系、auth.users 死引用、
  「自动路由」措辞、下载白名单维护、密码 8 位、测试计数 165→179。
- .env.example 重写(删 B_AI_API_KEY、补 OPENCODE 与全部可覆盖路径)。
- Makefile:lint 改 compileall(原手写清单漏了 6 个模块);test 注释改实话(环境无 pytest)。
- .gitignore 补 6 项;data/gateway.yaml*.bak 三个文件 git rm --cached(本地保留)。
- 新增 scripts/ci_check.sh:一条命令跑完 compileall + 单测 + i18n/SVG 体检 + vue-tsc + build。
- flake8 --select=F,E9 清到 0。

测试
- 179 passed / 0 failed(173→179)。新增会话落盘/过期丢弃、视频归属语义 + 端点级 404、
  env 值校验 + 沙箱写、口令下限。
- 修隐患:新增 GATEWAY_ENV_FILE 覆盖 —— 此前测试若覆盖写路径会直接改生产 data/.env。

CSP 结论
- 实测(A/B):去掉 'unsafe-eval' 后登录页 #app 全空、表单不渲染;根因是 vue-i18n 运行时
  消息编译器(打包产物里唯一一处 new Function)。正解是构建期预编译文案,不是放宽 CSP。
2026-09-18 22:45:20 +08:00

533 lines
26 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""OpenAI 兼容协议适配器。
Agnes / 火山方舟 两家均使用 OpenAI 兼容 API
(POST {base_url}/chat/completions),本适配器统一处理。
图像/视频端点可通过 media 配置覆盖:
- 图像:默认 {base_url}/images/generations(OpenAI 兼容)
- 视频:Agnes 用 {base_url}/videos 创建 + {poll_base}{poll_path}?video_id=...&model_name=... 轮询
"""
from __future__ import annotations
import json
import logging
import re
import uuid
from contextlib import asynccontextmanager
from typing import Any, AsyncIterator
import httpx
from app.adapters.base import BaseAdapter, json_or_raise
from app.config import (
PROTOCOL_CHAT,
EndpointSpec,
MODEL_PARAM_KEYS,
_default_endpoints,
)
from app.models import CHAT_CORE_KEYS, PROTECTED_VIDEO_KEYS, strip_protected
log = logging.getLogger("api-gateway")
# ── 上游"某参数只允许取某个值"的报错形态(第二十五轮)──
# 各家措辞不同,这里收录已实测到的两类:
# OpenCode Go: "Error from provider (Console Go): [invalid_request_error]
# invalid temperature: only 1 is allowed for this model"
# "max_tokens must be greater than 2"
# 参数名不写死 —— 同类约束也可能出现在 top_p / max_tokens 上。
_PARAM_ONLY_RE = re.compile(
r"invalid\s+([a-z_][a-z0-9_]*)\s*:\s*only\s+([-+]?\d+(?:\.\d+)?)\s+is allowed", re.I)
_PARAM_MIN_RE = re.compile(
r"([a-z_][a-z0-9_]*)\s+must be greater than\s+(\d+)", re.I)
class OpenAICompatAdapter(BaseAdapter):
"""适用于所有 OpenAI 兼容 /chat/completions 端点的适配器。
第二十七轮(三线直传)后它同时承担**协议直传**职责:同一家供应商的三条线
(chat/completions、messages、responses)共用这一个适配器、共用一个连接池,
差别只在「路径 + 鉴权头」——由 provider 的 `endpoints` 配置提供(见 config.EndpointSpec)。
直传路径**不翻译任何内容**:入站 body 原样出去,上游响应原样回来。
"""
def __init__(
self,
name: str,
base_url: str,
headers: dict[str, str] | None = None,
timeout: int = 120,
media=None,
requires_session_header: bool = False,
model_params: dict[str, dict[str, Any]] | None = None,
token: str = "",
endpoints: dict[str, EndpointSpec] | None = None,
):
super().__init__(name=name, base_url=base_url, timeout=timeout, media=media)
self._headers: dict[str, str] = headers or {}
# 第二十七轮: 每条协议线的出站配置(路径 / 鉴权方式 / 该线固定头)。
# 不传 = 三条标准线的默认值,所以旧调用点(含单测直接 new)行为不变。
self._endpoints: dict[str, EndpointSpec] = dict(endpoints or _default_endpoints())
# 裸 token:每条线要发的鉴权头不同(Bearer / x-api-key),所以不能在构造时就把
# header 拼死。没显式传就回头从静态 headers 里解析(兼容直接 new 的调用方)。
self._token = token or self._token_from_headers(self._headers)
# OpenCode Go 要求每个 /chat/completions 带稳定 x-opencode-session。
# 不能放静态 headers(_get_adapter 会缓存适配器、冻结 header),
# 所以在每次请求时动态生成一个 UUID 会话头。
self._requires_session = requires_session_header
# 模型级强制参数:model id → {参数名: 强制值}(来自 gateway.yaml 的 models[].params)
self._model_params: dict[str, dict[str, Any]] = {
k: dict(v) for k, v in (model_params or {}).items() if v
}
# 运行期自学习到的参数约束(进程内,不落盘):见 _learn_from_upstream_error。
# 仅作兜底 —— 管理员在 gateway.yaml 写死 params 后就不再需要它。
self._learned_params: dict[str, dict[str, Any]] = {}
@staticmethod
def _token_from_headers(headers: dict[str, str]) -> str:
"""从静态 headers 里反解 token(兼容历史调用方式:构造时就带 Authorization)。"""
auth = headers.get("Authorization") or headers.get("authorization") or ""
if auth.lower().startswith("bearer "):
return auth[7:].strip()
return headers.get("x-api-key") or ""
# ── 协议线(第二十七轮) ─────────────────────────
def endpoint(self, protocol: str) -> EndpointSpec | None:
"""取某条线的出站配置(None = 该供应商没有这条线)。"""
return self._endpoints.get(protocol)
def _path(self, protocol: str) -> str:
ep = self._endpoints.get(protocol)
if ep is None:
# 走到这里说明配置校验漏了(validate_config 会拦「模型声明了但供应商没配」),
# 抛清晰错误而不是退化成默认路径 —— 猜出来的地址只会收到 404,更难查。
raise ValueError(f"供应商 {self.name} 未配置协议线 {protocol}")
return ep.path
def auth_headers(self, protocol: str) -> dict[str, str]:
"""按该线的鉴权方式组装鉴权头(Bearer / x-api-key / 无)。
这是三线直传里"唯一必须做的 glue":同一个供应商的三条线鉴权方式可能不同
(实测 OpenCode Go:chat/completions 与 responses 认 `Authorization: Bearer`,
messages 认 `x-api-key`;用 Bearer 打 /messages 会 401 Missing API key)。
"""
ep = self._endpoints.get(protocol)
style = (ep.auth if ep else "bearer")
out: dict[str, str] = {}
if style == "bearer" and self._token:
out["Authorization"] = f"Bearer {self._token}"
elif style == "x-api-key" and self._token:
out["x-api-key"] = self._token
if ep:
out.update(ep.headers or {}) # 如 anthropic-version
return out
# ── 模型级强制参数 / 上游参数约束自学习(第二十五轮) ──
def _forced_params(self, model: str) -> dict[str, Any]:
"""该模型发往上游前**必须使用**的参数值。
两层,配置优先:`gateway.yaml` 的 `models[].params` > 运行期自学习值。
配置优先是刻意的 —— 管理员写死的口径是最终口径,自学习绝不能把它改掉。
"""
out = dict(self._learned_params.get(model) or {})
out.update(self._model_params.get(model) or {})
return out
def _learn_from_upstream_error(self, model: str, exc: Exception) -> dict[str, Any] | None:
"""上游 400 说"这个参数只允许 X"→ 记下 X,并返回修正后的参数集供重发。
返回 None = 报文里没识别出可修正的参数(调用方按原样抛错)。
这不是「重试」:报文一模一样地重发只会再吃一次同样的 400,必须先把参数改成
上游允许的值。学到之后会缓存到本适配器实例,后续请求直接按修正值组装 payload,
不再多跑这一轮往返;配置变更时 main 会丢弃适配器缓存,学习值随之失效。
"""
resp = getattr(exc, "response", None)
if resp is None or getattr(resp, "status_code", None) != 400:
return None
try:
text = resp.text or ""
except Exception:
return None
fixes: dict[str, Any] = {}
for m in _PARAM_ONLY_RE.finditer(text):
name = m.group(1).lower()
if name in MODEL_PARAM_KEYS:
raw = m.group(2)
fixes[name] = float(raw) if "." in raw else int(raw)
for m in _PARAM_MIN_RE.finditer(text):
name = m.group(1).lower()
if name in MODEL_PARAM_KEYS and name not in fixes:
fixes[name] = int(m.group(2)) + 1 # “must be greater than N” → 发 N+1
if not fixes:
return None
cfg_params = self._model_params.get(model) or {}
learned = dict(self._learned_params.get(model) or {})
changed: dict[str, Any] = {}
for k, v in fixes.items():
if k in cfg_params:
# 管理员已在 params 里写死该参数 → 不偷偷覆盖配置;但冲突必须说出来,
# 否则用户只会看到「明明配了却还是 400」,无从下手。
if cfg_params[k] != v:
log.warning("模型 %s 的 params.%s=%r 与上游要求(%r)冲突,仍按配置发送",
model, k, cfg_params[k], v)
continue
if learned.get(k) != v:
learned[k] = v
changed[k] = v
if not changed:
return None # 没学到新东西 → 不重发,避免在同一约束上来回打转
self._learned_params[model] = learned
log.warning("上游限制了模型 %s 的参数:%s —— 已自动修正并按修正值重发一次;"
"建议在 gateway.yaml 该模型下写死 params,省掉以后每次这一轮额外往返",
model, changed)
return self._forced_params(model)
def _req_headers(self, session_id: str | None = None,
protocol: str = PROTOCOL_CHAT) -> dict[str, str]:
"""每次请求的 headers:静态头 + 本条线的鉴权头 + 会话头。
session_id 由调用方传入(网关把对话的 conversation_id 透传过来):
- 有 → 同一段对话的所有请求共用同一个 session(上游据此做路由与缓存);
- 无 → 回退为每请求一个随机 UUID(仍能过上游的强校验,只是没有缓存收益)。
第二十七轮实测:OpenCode Go 的**三条线都硬性要求该头**(缺任一条 → 400
MissingSessionID),所以注入逻辑与协议线无关,统一在这里做。
"""
headers = dict(self._headers)
# 鉴权头按线走:先清掉静态头里可能残留的鉴权(历史写法:create_adapter 曾把
# Authorization 塞进静态 headers),再由 auth_headers 按该线的方式补上。
headers.pop("Authorization", None)
headers.pop("authorization", None)
headers.pop("x-api-key", None)
headers.update(self.auth_headers(protocol))
# 第三十轮: 这里原来写「无 session → 每请求一个随机 UUID(仍能过上游强校验,只是没有缓存收益)」,
# 那句话在第二十九轮之后**已经不对了** —— 网关三条协议线入口(chat 非流式/流式、batch、
# 三线直传)现在都传 `session_id`,随机回退只在"适配器被直接调用且没给 session"时才可能命中。
# 留 uuid4 是兜底(保证不缺头 → 不会 400 MissingSessionID),正常流量走不到这里。
if self._requires_session:
headers["x-opencode-session"] = session_id or uuid.uuid4().hex
return headers
def _media_headers(self) -> dict[str, str]:
"""媒体端点(图像生成 / 视频创建 / 视频轮询)的 headers。
媒体端点不属于「三条协议线」,所以不走 `_req_headers` —— 历史口径是固定用 Bearer。
第二十七轮把鉴权头改成「按协议线在 `_req_headers` 里组装」之后,这三个调用点却还在
用静态 `self._headers`,而 `create_adapter` 已经不再往静态头里塞 Authorization
⇒ **token 一个都没带出去**。真机表现:`POST /v1/images/generations` 上游 401
「未提供令牌」(同一个 key 直接 curl 同一个地址是 200)。
这里统一补回来:静态头 + Bearer(有 token 时)+ 会话头(供应商要求时)。
"""
headers = dict(self._headers)
if self._token:
headers["Authorization"] = f"Bearer {self._token}"
# 第三十轮: 这里的会话头**故意**保持每请求随机,不是漏改。
# 媒体端点(图像/视频)是一次性任务,没有"同一会话复读同一大前缀"的场景,
# 也就没有前缀缓存可吃;反过来,若给它一个跨请求固定的会话,反而会让上游把
# 互不相关的图片/视频任务记到同一个会话名下,污染那边的会话视图。
# 注意当前配了媒体能力的供应商都不是 opencode(opencode 无 media),这行实际走不到。
if self._requires_session:
headers["x-opencode-session"] = uuid.uuid4().hex
return headers
# ── 协议直传(第二十七轮)────────────────────────
# 「入站是什么格式,出站就是什么格式」:这两个原语把入站 body **原样**发到该线的上游
# 地址,**不翻译任何字段**。网关只做三件事:① 挑对供应商与线;② 把 model 改成真实
# id 并盖上模型级强制参数;③ 原样把响应(含 SSE)交回客户端。
# 中间不做 has_images 之类的语义判断,也不解析 body 结构。
def prepare_payload(self, model: str, payload: dict[str, Any]) -> dict[str, Any]:
"""直传前的定点改写:model 换成真实 id + 盖模型级强制参数(其余一律不动)。
- model:入站就是真实模型 id(第二十七轮起路由别名已删除,不再有别名解析,
网关也不会替你换模型)—— 这里仍保留"定点改写 model"的能力:调用方写的 id
必须落到某条线能认的 id 上;
- 强制参数:`models[].params`(如 kimi-k2.7-code 只接受 temperature=1)在直传里
同样必须生效,否则"直传"就成了"漏掉网关的硬约束"。
这两处是**唯一**允许改写入站 body 的地方(改的都是"发给谁/必须用什么参数",
不是协议语义),其余字段一律原样。
"""
out = dict(payload)
out["model"] = model
forced = self._forced_params(model)
if forced:
out.update(forced)
return out
async def raw_json(self, protocol: str, payload: dict[str, Any],
session_id: str | None = None) -> tuple[int, Any]:
"""非流式直传:返回 (上游状态码, 上游 JSON/文本)。
刻意**不 raise_for_status**:直传口径下上游的错误体要原样交回客户端
(老板决策:"其他都不转" —— 错误文案也不转)。熔断/指标由调用方按状态码记。
"""
async with self._lease() as client:
resp = await client.post(self._path(protocol), json=payload,
headers=self._req_headers(session_id, protocol))
body = resp.content
ctype = resp.headers.get("content-type", "")
if "application/json" in ctype:
try:
return resp.status_code, json.loads(body)
except (ValueError, json.JSONDecodeError):
pass
# 非 JSON(或声明 JSON 但解析失败):把原始文本交回,别在这里编造结构
return resp.status_code, body.decode("utf-8", "replace")
@asynccontextmanager
async def raw_stream(self, protocol: str, payload: dict[str, Any],
session_id: str | None = None):
"""流式直传:上下文内可直接读 `resp`(状态码 + 字节流)。
为什么用 asynccontextmanager 而不是普通 async generator:调用方需要**先看到
状态码**再决定返回 SSE(200)还是上游的 JSON 错误(4xx/5xx)。同时 lease 必须在
整个流式期间持有(热重载/关闭不会掐断在途流,与 _stream_once 同一处理)。
"""
async with self._lease() as client:
async with client.stream("POST", self._path(protocol), json=payload,
headers=self._req_headers(session_id, protocol)) as resp:
yield resp
def _build_payload(
self,
model: str,
messages: list[dict],
temperature: float | None,
top_p: float | None,
max_tokens: int | None,
stream: bool,
stop: str | list[str] | None,
tools: list[dict] | None,
tool_choice: str | dict | None,
extra: dict[str, Any] | None,
) -> dict[str, Any]:
payload: dict[str, Any] = {"model": model, "messages": messages, "stream": stream}
if temperature is not None:
payload["temperature"] = temperature
if top_p is not None:
payload["top_p"] = top_p
if max_tokens is not None:
payload["max_tokens"] = max_tokens
if stop is not None:
payload["stop"] = stop
if tools:
payload["tools"] = tools
if tool_choice is not None:
payload["tool_choice"] = tool_choice
# 合并供应商特有参数(如 Agnes 的 chat_template_kwargs)。
# 第六轮安全修复: 先剔除核心键 —— 否则 `extra={"model": ..., "stream": ...}`
# 会覆盖掉上面写好的值(路由劫持 / 协议错配)。models.upstream_extra() 已过滤,
# 这里是适配器侧的最后一道防线。
# 只剔除"本函数上面刚写好的核心键";其余(网关 _PASSTHROUGH 的标准参数、
# 以及供应商特有参数)必须放行 —— 见 models.CHAT_CORE_KEYS 的说明。
if extra:
payload.update(strip_protected(extra, CHAT_CORE_KEYS))
# 第二十五轮: 模型级强制参数放在**最后**覆盖 —— 客户端(含 extra 逃生舱)改不动它。
# 这是应对"上游只接受某个值"的最终口径,优先级高于客户端的一切输入。
forced = self._forced_params(model)
if forced:
payload.update(forced)
return payload
async def chat(
self,
model: str,
messages: list[dict],
temperature: float | None = None,
top_p: float | None = None,
max_tokens: int | None = None,
stream: bool = False,
stop: str | list[str] | None = None,
tools: list[dict] | None = None,
tool_choice: str | dict | None = None,
extra: dict[str, Any] | None = None,
session_id: str | None = None,
) -> dict[str, Any]:
payload = self._build_payload(
model, messages, temperature, top_p, max_tokens,
stream, stop, tools, tool_choice, extra,
)
try:
return await self._post_chat(payload, session_id)
except httpx.HTTPStatusError as e:
# 上游嫌参数(如 temperature)不合法时,按它要求的值修正后**重发一次**。
# fixed 为 None(不是参数约束 / 已学过仍失败)则原样抛错,不做无谓重发。
fixed = self._learn_from_upstream_error(model, e)
if fixed is None:
raise
return await self._post_chat({**payload, **fixed}, session_id)
async def _post_chat(self, payload: dict[str, Any], session_id: str | None) -> dict[str, Any]:
"""执行一次非流式 /chat/completions 请求(不含参数修正逻辑)。"""
# Bug 4 修复: 用 lease 占用 client,热重载 close 会等本次请求结束才真正关连接
async with self._lease() as client:
resp = await client.post(self._path(PROTOCOL_CHAT), json=payload,
headers=self._req_headers(session_id, PROTOCOL_CHAT))
resp.raise_for_status()
data = json_or_raise(resp)
# 统一返回格式
return {
"provider": self.name,
"model": payload.get("model", ""),
"choices": data.get("choices", []),
"usage": data.get("usage"),
"raw": data,
"id": data.get("id", ""),
}
async def chat_stream(
self,
model: str,
messages: list[dict],
temperature: float | None = None,
top_p: float | None = None,
max_tokens: int | None = None,
stop: str | list[str] | None = None,
tools: list[dict] | None = None,
tool_choice: str | dict | None = None,
extra: dict[str, Any] | None = None,
session_id: str | None = None,
) -> AsyncIterator[dict]:
payload = self._build_payload(
model, messages, temperature, top_p, max_tokens,
True, stop, tools, tool_choice, extra,
)
started = False
try:
async for chunk in self._stream_once(payload, session_id):
started = True
yield chunk
return
except httpx.HTTPStatusError as e:
# 已经开始吐内容就不能重发(会重复输出 / 串话);只有"开局就被上游 400 顶回来"
# 才允许按上游要求修正参数重来一次。
if started:
raise
fixed = self._learn_from_upstream_error(model, e)
if fixed is None:
raise
payload = {**payload, **fixed}
async for chunk in self._stream_once(payload, session_id):
yield chunk
async def _stream_once(self, payload: dict[str, Any],
session_id: str | None) -> AsyncIterator[dict]:
"""执行一次流式 /chat/completions(不含参数修正逻辑)。"""
# Bug 4 修复: lease 在整个流式期间持有占用,热重载/关闭不会掐断在途流
async with self._lease() as client:
async with client.stream(
"POST", self._path(PROTOCOL_CHAT), json=payload,
headers=self._req_headers(session_id, PROTOCOL_CHAT)
) as resp:
resp.raise_for_status()
async for line in resp.aiter_lines():
if not line.startswith("data: "):
continue
raw = line[6:]
if raw.strip() == "[DONE]":
yield {"done": True}
break
# 本轮修复: 上游可能有非 JSON 的行(keep-alive `data: ping`、空行、
# 注释、被截断的半行)。此前 json.loads 抛异常会直接**中断整个流式响应**,
# 客户端拿到一半就断。现在跳过坏行并继续。
try:
data = json.loads(raw)
except (json.JSONDecodeError, ValueError):
continue
yield data
# ── 图像生成 ────────────────────────────────────
async def generate_image(
self,
model: str,
prompt: str,
size: str | None = None,
ratio: str | None = None,
image: list[str] | None = None,
n: int = 1,
extra: dict[str, Any] | None = None,
) -> dict[str, Any]:
endpoint = self.media.image_endpoint or "/images/generations"
# Bug 12: 默认档位来自 media.image_default_size(默认 1K 兜底,Agnes 要求 size 必填)
size = size or self.media.image_default_size or "1K"
payload: dict[str, Any] = {"model": model, "prompt": prompt, "size": size}
# #5: 仅当需要多张才带 n(Agnes 一次一张,n=1 省略避免噪音)
if n and n != 1:
payload["n"] = n
if ratio:
payload["ratio"] = ratio
# 图生图 / 多图:图像 URL 放 extra_body.image(Agnes 写法)
extra_body: dict[str, Any] = dict(extra or {})
if image:
extra_body["image"] = image
if extra_body:
payload["extra_body"] = extra_body
async with self._lease() as client:
resp = await client.post(endpoint, json=payload, headers=self._media_headers())
resp.raise_for_status()
data = json_or_raise(resp)
# 统一:返回 data 数组
return {"data": data.get("data", []), "raw": data}
# ── 视频创建(异步任务) ────────────────────────
async def create_video(
self,
model: str,
prompt: str,
seconds: str = "5",
mode: str = "text",
aspect_ratio: str = "16:9",
size: str = "720P",
extra: dict[str, Any] | None = None,
) -> dict[str, Any]:
# ── Agnes 风格:POST {base}/videos,seconds/mode/size/aspect_ratio/n ──
endpoint = self.media.video_create_endpoint or "/videos"
payload: dict[str, Any] = {
"model": model,
"prompt": prompt,
"seconds": seconds,
"mode": mode,
"size": size,
"aspect_ratio": aspect_ratio,
"n": 1,
}
# 合并模式专用字段(first_frame/last_frame/images/audios 等);
# 第六轮: 但不允许覆盖 model/prompt/seconds/mode/size/aspect_ratio(同 chat 的越权面)。
for k, v in strip_protected(extra, PROTECTED_VIDEO_KEYS).items():
payload[k] = v
async with self._lease() as client:
resp = await client.post(endpoint, json=payload, headers=self._media_headers())
resp.raise_for_status()
data = json_or_raise(resp)
# video_id 用于查询;id/task_id 是任务 id
return {
"video_id": data.get("video_id") or data.get("id") or data.get("task_id"),
"raw": data,
}
# ── 视频轮询 ────────────────────────────────────
async def poll_video(self, video_id: str, model: str = "", extra: dict[str, Any] | None = None) -> dict[str, Any]:
mname = self.media.video_model_name or model or ""
poll_base = self.media.video_poll_base or self.base_url
poll_path = self.media.video_poll_path or "/agnesapi"
params: dict[str, str] = {"video_id": video_id}
if mname:
params["model_name"] = mname
# 轮询用绝对 URL(poll_base 可能是去掉 /v1 的域名根)
url = poll_base.rstrip("/") + poll_path
async with self._lease() as client:
resp = await client.get(url, params=params, headers=self._media_headers())
resp.raise_for_status()
data = json_or_raise(resp)
return {"raw": data}