free-short-video 6.5.2 → 7.0.0

package/README.md

@@ -1,20 +1,52 @@
 ---
 
-# What's New in v6.5.2
+# What's New in v7.0.0
 
 ## What's New
 
 ### Features & Improvements
 
-* **Style / prompt preset library.** Creative and poetry video forms now offer a style picker beside the style input. It ships with 18 curated, non-overlapping presets across six categories (photographic, cinematic, oriental, painting, animation, fantasy), each structured as medium + lighting + color + texture to compose cleanly with your subject prompt. Clicking a preset fills the style box in one click and you can keep editing it. Saved as a preset is supported too.
-* **One-click preset reuse with controls.** The picker lists your custom presets first, brings recently used presets to the front, shows the full prompt on hover, and lets you save the current style edit as a named custom preset. System presets are read-only; custom presets can be renamed and deleted.
-* **Media gallery (read-only).** A new parallel "Gallery" tab shows finished videos and images in a filterable grid (type × status). Video cards use the native first frame as a cover with hover playback, and images link to the existing media endpoint. Clicking a card opens the task detail. The gallery is strictly read-only — it exposes no delete or batch operations — and reads entirely from the existing task directory, so no new data files are written into task folders.
-* **Lazy thumbnail cache (gallery).** For larger galleries, video covers are extracted to a rebuildable cache under the config directory (never inside task folders) to keep the grid snappy without touching the task directory structure.
-* **Localization.** All preset category names and system-preset display names are translated across all 22 supported interface languages; the English and Chinese key sets are fully aligned.
+- **Custom text model providers (OpenAI-compatible / Anthropic-compatible).** Configure any
+  LLM endpoint with `base URL + API key` and two supported wire protocols
+  (`openai-completions`, `anthropic-messages`). Once selected, every text call — screenplay
+  breakdown, scene planning, poetry segmentation, image-prompt rewriting — is routed to your
+  provider automatically. The built-in Agnes provider is always available, cannot be deleted,
+  and keeps the previous behaviour when no custom provider is selected.
+- **Provider management panel.** A dedicated settings section lists all text providers, lets
+  you add, edit and delete them, and keeps the Agnes key/domain editing inside the provider
+  modal. Keys are masked in the UI, and the provider's model list is a single editable list:
+  fetch it from the endpoint or type model ids by hand. Model selection is a two-level
+  provider → model picker that merges the models of all providers.
+- **Interface-language aware backend messages.** Task progress messages, failure panels, HTTP
+  error details and the diagnostics report are now localized according to the UI language
+  instead of being hard-coded Chinese. The UI language travels with every request
+  (`X-Agnes-UI-Lang`, falling back to `Accept-Language`), is snapshotted into each task at
+  creation time, and therefore does not drift if the user switches language later. Chinese and
+  English are covered; the remaining languages fall back to the existing behaviour.
+- **Clearer network failure diagnosis.** TLS handshake resets (`connection reset`) are now
+  attributed to local-connection problems, and the diagnostics report shows the interface
+  language of the reporting user, making failure reports easier to triage.
+
+### Refactoring & Optimizations
+
+- **Decoupled text-generation layer.** A new protocol-client layer
+  (`core/api/providers/` → base / OpenAI / Anthropic) plus a provider factory replaces the two
+  hard-coded Agnes chat client constructions, so pipelines and the screenwriter are untouched
+  while the underlying model source becomes pluggable. Custom providers reuse the existing
+  shared rate limiter and exponential-backoff retry policy, and failures are recorded in the
+  same error log as before.
+- **Backend i18n runtime.** A new translation runtime plus request-scoped language middleware
+  gives the FastAPI side the same localization guarantees the frontend already had, with a
+  safe fallback chain that never turns a missing translation into a request failure.
 
 ### Bug Fixes
 
-* Creative and poetry forms no longer pre-fill the style field with hardcoded Chinese text on non-Chinese interfaces; an empty value is now a valid choice, matching the backend default.
+- Model pulling for an already saved provider now reuses its stored credentials instead of
+  falling back to the Agnes key.
+- The built-in Agnes provider no longer appears twice in the provider picker and is now
+  labelled as text-only.
+- Non-Chinese interfaces no longer receive hard-coded Chinese network-diagnosis and task
+  messages (issue #64).
 
 ---
 

package/core/api/chat_providers.py

@@ -0,0 +1,55 @@
+"""core.api.chat_providers — 文本模型客户端工厂（v7.0 多文本模型）。
+
+按当前所选文本供应商（``models.text_provider``）分派：
+- 空 / ``agnes`` → ``AgnesChatAPI``（现有行为 100% 不变）；
+- 自定义供应商 → ``OpenAIChatClient`` / ``AnthropicChatClient``。
+
+供 screenwriter / video_routes 等取代硬编码的 ``AgnesChatAPI(...)`` 构造点。
+"""
+
+from __future__ import annotations
+
+import logging
+
+from core.config import API_ANTHROPIC, resolve_text_chat
+
+logger = logging.getLogger(__name__)
+
+
+def get_or_build_text_chat_client(api_key: str | None = None, model: str | None = None):
+    """构造当前所选文本供应商的聊天客户端（与 AgnesChatAPI 相同接口）。
+
+    Args:
+        api_key: 显式 API Key。仅对 agnes 供应商生效（等价原 ``AgnesChatAPI``
+            构造时 `api_key=api_key`）；自定义供应商使用其自身配置的 api_key。
+        model: 显式模型；省略则使用当前所选配置（``models.text`` 或供应商首个模型）。
+
+    Returns:
+        满足 ``chat / chat_json / chat_multimodal`` 接口的客户端实例。
+    """
+    cfg = resolve_text_chat()
+    if cfg["kind"] == "agnes":
+        from core.api.agnes_chat import AgnesChatAPI
+        from core.config import get_api_key
+
+        return AgnesChatAPI(
+            api_key=api_key or get_api_key(),
+            model=model or cfg["model"],
+        )
+    # custom
+    m = model or cfg["model"]
+    if cfg["api"] == API_ANTHROPIC:
+        from core.api.providers.anthropic import AnthropicChatClient
+
+        return AnthropicChatClient(
+            base_url=cfg["base_url"],
+            api_key=cfg["api_key"],
+            model=m,
+        )
+    from core.api.providers.openai import OpenAIChatClient
+
+    return OpenAIChatClient(
+        base_url=cfg["base_url"],
+        api_key=cfg["api_key"],
+        model=m,
+    )

package/core/api/providers/__init__.py

@@ -0,0 +1,23 @@
+"""core.api.providers — 可插拔文本模型供应商的协议客户端包。
+
+提供 OpenAI 兼容（``OpenAIChatClient``）与 Anthropic 兼容（``AnthropicChatClient``）
+两种线协议实现，以及端点拼接纯函数（``get_chat_endpoint`` / ``get_models_endpoint``）。
+"""
+
+from core.api.providers.anthropic import AnthropicChatClient
+from core.api.providers.base import (
+    get_chat_endpoint,
+    get_models_endpoint,
+    probe_text_models,
+    request_with_retry,
+)
+from core.api.providers.openai import OpenAIChatClient
+
+__all__ = [
+    "AnthropicChatClient",
+    "OpenAIChatClient",
+    "get_chat_endpoint",
+    "get_models_endpoint",
+    "probe_text_models",
+    "request_with_retry",
+]

package/core/api/providers/anthropic.py

@@ -0,0 +1,84 @@
+"""core.api.providers.anthropic — Anthropic 兼容线协议客户端
+
+协议：``POST {base}/v1/messages``（base 已含 /v1 则 ``{base}/messages``），Header
+``x-api-key`` + ``anthropic-version: 2023-06-01``；body：``model / system(顶层) /
+messages / max_tokens / temperature``。取结果 ``data.content[0].text``。
+
+多模态本期不做：``chat_multimodal`` 告警并退回纯文本（忽略 images）。
+"""
+
+from __future__ import annotations
+
+import logging
+
+import requests
+
+from core.api.providers.base import (
+    BaseProviderClient,
+    request_with_retry,
+)
+
+logger = logging.getLogger(__name__)
+
+_ANTHROPIC_VERSION = "2023-06-01"
+
+
+class AnthropicChatClient(BaseProviderClient):
+    """Anthropic Messages API 兼容客户端（text only）。"""
+
+    api = "anthropic-messages"
+
+    def _chat_endpoint(self) -> str:
+        base = self.base_url
+        if base.endswith("/v1"):
+            return f"{base}/messages"
+        return f"{base}/v1/messages"
+
+    def _auth_headers(self) -> dict:
+        return {
+            "x-api-key": self.api_key,
+            "anthropic-version": _ANTHROPIC_VERSION,
+            "Content-Type": "application/json",
+        }
+
+    def _extract_content(self, data: dict) -> str:
+        content = data.get("content") or []
+        if content:
+            return content[0].get("text", "")
+        return ""
+
+    def _request(self, payload: dict, timeout: int = 120) -> dict:
+        url = self._chat_endpoint()
+        headers = self._auth_headers()
+        return request_with_retry(
+            requests.post, url, headers, payload=payload, timeout=timeout,
+        )
+
+    def chat(self, system_prompt: str, user_prompt: str, max_tokens: int = 4096) -> str:
+        logger.info(
+            f"[AnthropicProvider] Calling chat ({self.model}), prompt: {len(user_prompt)} chars..."
+        )
+        data = self._request(
+            {
+                "model": self.model,
+                "system": system_prompt,
+                "messages": [{"role": "user", "content": user_prompt}],
+                "max_tokens": max_tokens,
+                "temperature": 0.7,
+            }
+        )
+        return self._extract_content(data)
+
+    def chat_multimodal(
+        self,
+        system_prompt: str,
+        text_prompt: str,
+        image_paths: list,
+        max_tokens: int = 4096,
+    ) -> str:
+        # 本期不支持 Anthropic 多模态：告警并退回纯文本（忽略 images）
+        logger.warning(
+            f"[AnthropicProvider] Multimodal not supported, falling back to text-only "
+            f"({len(image_paths)} image(s) ignored)"
+        )
+        return self.chat(system_prompt, text_prompt, max_tokens=max_tokens)

package/core/api/providers/base.py

@@ -0,0 +1,273 @@
+"""core.api.providers.base — 文本供应商协议客户端的共享底层
+
+提供：
+- 端点拼接纯函数 ``get_chat_endpoint`` / ``get_models_endpoint``（OpenAI 兼容 /
+  Anthropic 兼容的 /v1 是否已含处理）；
+- 受限速 + 指数退避的底层请求 ``request_with_retry``（不复用 Agnes KeyRing，
+  仅共享全局令牌桶 `get_rate_limiter()`；5xx/429 最多 3 次指数退避，4xx 直接抛）；
+- ``BaseProviderClient``：OpenAI / Anthropic 客户端共用的胶水（chat_json 解析、
+  多模态拼装 header 等），具体协议差异在子类实现。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+
+import requests
+
+from core.api.agnes_chat import (
+    _JSON_BLOCK_RE,
+    repair_json,
+    strip_code_fence,
+)
+from core.api.error_collector import collect_error, collect_error_from_exception
+from core.api.rate_limiter import get_rate_limiter
+from core.config import API_OPENAI
+
+logger = logging.getLogger(__name__)
+
+_MAX_RETRIES = 3
+_RETRY_BASE_DELAY = 15  # 秒，指数退避基数
+
+
+def get_chat_endpoint(base_url: str, api: str) -> str:
+    """OpenAI 兼容 chat 端点：``{base}/chat/completions``（base_url 去除尾 `/`）。
+
+    （Anthropic 聊天使用独立构造，见 ``_anthropic_messages_endpoint``；本函数对
+    Anthropic 语义为 ``{base}/v1/messages``，供探测结果一致性参照。）
+    """
+    base = (base_url or "").rstrip("/")
+    if api == "anthropic-messages":
+        if base.endswith("/v1"):
+            return f"{base}/messages"
+        return f"{base}/v1/messages"
+    return f"{base}/chat/completions"
+
+
+def get_models_endpoint(base_url: str, api: str) -> str:
+    """OpenAI 兼容模型列表端点：``{base}/models``。
+
+    Anthropic 语义：base 以 ``/v1`` 结尾 → ``{base}/models``，否则 ``{base}/v1/models``。
+    """
+    base = (base_url or "").rstrip("/")
+    if api == "anthropic-messages":
+        if base.endswith("/v1"):
+            return f"{base}/models"
+        return f"{base}/v1/models"
+    return f"{base}/models"
+
+
+def request_with_retry(
+    requester,
+    url: str,
+    headers: dict,
+    *,
+    payload: dict | None = None,
+    json_body: bool = True,
+    timeout: int = 120,
+) -> dict:
+    """受限速的指数退避请求（自定义供应商专用，不换 Key）。
+
+    规则：
+    1. 每次请求前 ``get_rate_limiter().acquire()``（共享桶）；
+    2. 5xx / 429 → 指数退避（delay = 15 × (retries+1)），最多 3 次；
+    3. 4xx（非 429）不重试，直接 ``raise requests.HTTPError``；
+    4. 失败调用 ``collect_error`` / ``collect_error_from_exception`` 落盘。
+    """
+    prompt = ""
+    if payload and json_body:
+        prompt = _extract_prompt_from_payload(payload)
+    retries = 0
+    while True:
+        get_rate_limiter().acquire()
+        try:
+            if json_body:
+                resp = requester(url, headers=headers, json=payload, timeout=timeout)
+            else:
+                resp = requester(url, headers=headers, timeout=timeout)
+        except (requests.ConnectionError, requests.Timeout) as e:
+            collect_error_from_exception(
+                "chat", "chat", exc=e, prompt=prompt, retry_count=retries,
+            )
+            if retries < _MAX_RETRIES:
+                delay = _RETRY_BASE_DELAY * (retries + 1)
+                logger.warning(
+                    f"[ChatProvider] {type(e).__name__}, 退避 {delay}s 后重试 "
+                    f"({retries + 1}/{_MAX_RETRIES})"
+                )
+                time.sleep(delay)
+                retries += 1
+                continue
+            raise
+        if resp.status_code == 429 or resp.status_code >= 500:
+            if retries < _MAX_RETRIES:
+                delay = _RETRY_BASE_DELAY * (retries + 1)
+                logger.warning(
+                    f"[ChatProvider] HTTP {resp.status_code}, 退避 {delay}s 后重试 "
+                    f"({retries + 1}/{_MAX_RETRIES})"
+                )
+                time.sleep(delay)
+                retries += 1
+                continue
+            # 重试耗尽：记录最终失败
+            collect_error(
+                "chat", "chat",
+                prompt=prompt,
+                error_type="RateLimit429" if resp.status_code == 429 else f"HTTP{resp.status_code}",
+                error_message=f"HTTP {resp.status_code}: retries exhausted",
+                status_code=resp.status_code,
+                response_body=resp.text,
+                retry_count=_MAX_RETRIES,
+            )
+            resp.raise_for_status()
+        if resp.status_code >= 400:
+            # 4xx（含 429 已耗尽）不可重试
+            try:
+                collect_error(
+                    "chat", "chat",
+                    prompt=prompt,
+                    error_type=f"HTTP{resp.status_code}",
+                    error_message=f"HTTP {resp.status_code}: {resp.text[:500]}",
+                    status_code=resp.status_code,
+                    response_body=resp.text[:5000],
+                    retry_count=retries,
+                )
+            except Exception:
+                pass
+            resp.raise_for_status()
+        return resp.json()
+
+
+def _extract_prompt_from_payload(payload: dict) -> str:
+    """从 Chat payload 中提取 user prompt 文本（用于错误收集）。"""
+    messages = payload.get("messages", [])
+    for msg in reversed(messages):
+        content = msg.get("content", "")
+        if isinstance(content, list):
+            texts = [
+                item.get("text", "")
+                for item in content
+                if isinstance(item, dict) and item.get("type") == "text"
+            ]
+            if texts:
+                return texts[0]
+        elif isinstance(content, str) and content.strip():
+            return content
+    return ""
+
+
+class BaseProviderClient:
+    """协议客户端基类：持有 base_url/api_key/model，含共享的 chat_json 解析逻辑。
+
+    子类必须实现：``_auth_headers()``、``chat()``、``chat_multimodal()``。
+    """
+
+    api = API_OPENAI
+
+    def __init__(self, base_url: str, api_key: str, model: str):
+        self.base_url = (base_url or "").rstrip("/")
+        self.api_key = api_key
+        self.model = model
+
+    def _auth_headers(self) -> dict:
+        raise NotImplementedError
+
+    def _extract_content(self, data: dict) -> str:
+        raise NotImplementedError
+
+    def _request(self, payload: dict, timeout: int = 120) -> dict:
+        url = get_chat_endpoint(self.base_url, self.api)
+        headers = self._auth_headers()
+        return request_with_retry(
+            requests.post, url, headers, payload=payload, timeout=timeout,
+        )
+
+    def chat_json(self, system_prompt: str, user_prompt: str, max_tokens: int = 4096) -> dict:
+        """Chat 调用并解析 JSON 响应（与 agnes_chat.chat_json 一致的健壮流程）。"""
+        for retry in range(2):
+            content = self.chat(system_prompt, user_prompt, max_tokens=max_tokens)
+            cleaned = strip_code_fence(content)
+            try:
+                return json.loads(cleaned)
+            except ValueError:
+                pass
+            match = _JSON_BLOCK_RE.search(cleaned)
+            if match:
+                try:
+                    return json.loads(match.group())
+                except ValueError:
+                    pass
+            if repair_json is not None:
+                try:
+                    repaired = repair_json(cleaned, return_objects=True)
+                    if isinstance(repaired, dict):
+                        logger.info(f"[{self._log_prefix}] JSON repaired via json_repair")
+                        return repaired
+                except Exception:
+                    pass
+            if retry == 0:
+                logger.warning(f"[{self._log_prefix}] JSON parse failed, retrying chat call...")
+                continue
+            preview = content[:200]
+            error_msg = (
+                f"[{self._log_prefix}] Failed to parse JSON after 2 attempts. "
+                f"Response preview: {preview}..."
+            )
+            collect_error(
+                "chat", "chat_json",
+                prompt=user_prompt, system_prompt=system_prompt,
+                error_type="JSONParseError",
+                error_message=error_msg,
+                response_body=content[:5000],
+                retry_count=2,
+            )
+            raise ValueError(error_msg)
+        raise ValueError(f"[{self._log_prefix}] Unexpected flow in chat_json")
+
+    @property
+    def _log_prefix(self) -> str:
+        return self.__class__.__name__
+
+
+def probe_text_models(base_url: str, api_key: str, api: str) -> list:
+    """用传入的 base_url+key+api 探测模型列表（不落盘，用于 test 端点）。
+
+    OpenAI 兼容用 ``Authorization: Bearer``；Anthropic 兼容用 ``x-api-key`` +
+    ``anthropic-version``。成功返回模型 id 列表，失败抛出 ``requests.HTTPError``。
+
+    Args:
+        base_url: 用户输入的 base_url。
+        api_key: 用户此刻输入的 key。
+        api: 线协议（openai-completions / anthropic-messages）。
+
+    Returns:
+        模型 id 列表（``data[].id`` / ``data[].id``）。
+
+    Raises:
+        requests.HTTPError: 4xx/5xx/网络错误（由调用方捕获返回 ``{ok:false,error}``）。
+    """
+    url = get_models_endpoint(base_url, api)
+    headers = {"Content-Type": "application/json"}
+    if api == "anthropic-messages":
+        headers["x-api-key"] = api_key
+        headers["anthropic-version"] = "2023-06-01"
+    else:
+        headers["Authorization"] = f"Bearer {api_key}"
+    resp = requests.get(url, headers=headers, timeout=60)
+    if resp.status_code >= 400:
+        try:
+            logger.warning(
+                f"[ChatProvider] Probe models failed HTTP {resp.status_code}: {resp.text[:500]}"
+            )
+        except Exception:
+            pass
+        resp.raise_for_status()
+    data = resp.json()
+    models = data.get("data") or []
+    ids = []
+    for m in models:
+        if isinstance(m, dict) and m.get("id"):
+            ids.append(str(m["id"]))
+    return ids

package/core/api/providers/openai.py

@@ -0,0 +1,93 @@
+"""core.api.providers.openai — OpenAI 兼容线协议客户端
+
+协议：``POST {base}/chat/completions``，Header ``Authorization: Bearer <key>``，
+body 与 Agnes 相同结构；多模态 content 为列表 + image_url（base64 data URI 透传）。
+取结果 ``data.choices[0].message.content``。
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import mimetypes
+import os
+
+from core.api.providers.base import BaseProviderClient
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIChatClient(BaseProviderClient):
+    """OpenAI 兼容协议客户端（text + multimodal）。"""
+
+    api = "openai-completions"
+
+    def _auth_headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def _image_to_b64_uri(self, path: str) -> str:
+        """将本地图片转为 OpenAI ``data:`` URI（与 agnes_chat 一致）。"""
+        with open(path, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode("utf-8")
+        mime = mimetypes.guess_type(path)[0] or "image/png"
+        return f"data:{mime};base64,{b64}"
+
+    def _extract_content(self, data: dict) -> str:
+        return data["choices"][0]["message"]["content"]
+
+    def chat(self, system_prompt: str, user_prompt: str, max_tokens: int = 4096) -> str:
+        logger.info(
+            f"[OpenAIProvider] Calling chat ({self.model}), prompt: {len(user_prompt)} chars..."
+        )
+        data = self._request(
+            {
+                "model": self.model,
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+                "temperature": 0.7,
+                "max_tokens": max_tokens,
+            }
+        )
+        return self._extract_content(data)
+
+    def chat_multimodal(
+        self,
+        system_prompt: str,
+        text_prompt: str,
+        image_paths: list,
+        max_tokens: int = 4096,
+    ) -> str:
+        messages = [{"role": "system", "content": system_prompt}]
+        user_content = [{"type": "text", "text": text_prompt}]
+        for img_path in image_paths:
+            if img_path.startswith(("http://", "https://")):
+                user_content.append({
+                    "type": "image_url",
+                    "image_url": {"url": img_path},
+                })
+            elif os.path.exists(img_path):
+                b64_uri = self._image_to_b64_uri(img_path)
+                user_content.append({
+                    "type": "image_url",
+                    "image_url": {"url": b64_uri},
+                })
+        messages.append({"role": "user", "content": user_content})
+        logger.info(
+            f"[OpenAIProvider] Calling multimodal ({self.model}), "
+            f"{len(image_paths)} image(s), prompt: {len(text_prompt)} chars..."
+        )
+        data = self._request(
+            {
+                "model": self.model,
+                "messages": messages,
+                "temperature": 0.7,
+                "max_tokens": max_tokens,
+            },
+            timeout=300,
+        )
+        return self._extract_content(data)