trip-moments-skill 1.0.0

package/.agents/skills/trip-moments/scripts/aiclient.py

@@ -0,0 +1,547 @@
+"""AI client adapters for the trip-moments skill.
+
+Providers, all detected via environment variables:
+
+  Self-hosted / aggregated gateway (highest priority, all three abilities):
+    TRIP_AI_BASE_URL + TRIP_AI_API_KEY   explicit trip gateway; beats SiliconFlow
+    OPENAI_BASE_URL + OPENAI_API_KEY     generic OpenAI-style gateway
+    Routes by model name (TRIP_VL_MODEL / TRIP_EDIT_MODEL / TRIP_T2I_MODEL):
+    - vision:            /chat/completions with image_url parts
+    - gpt-image series:  native protocol, /images/edits multipart for editing,
+                         /images/generations JSON with "size" for t2i
+    - gemini image models (nano-banana family): chat-only, image in -> image
+                         out (data URI in reply); /images/* rejects them
+    - others:            /images/generations JSON with image_size + data URL
+  SiliconFlow:
+    SILICONFLOW_API_KEY  base https://api.siliconflow.cn/v1 (Qwen-Image-Edit,
+                         GLM-4.5V vision, Kolors t2i)
+  Aliyun DashScope:
+    DASHSCOPE_API_KEY    wanx2.1-imageedit presets (async task API)
+  Zhipu BigModel:
+    ZHIPU_API_KEY        glm-4v vision + glm-image text-to-image (no editing)
+
+Env values are read through _env_clean(): setx tends to store stray quotes
+literally, which breaks Bearer auth. Size parameter auto-selects "size" for
+gpt-image models, "image_size" otherwise; TRIP_SIZE_PARAM overrides.
+"""
+from __future__ import annotations
+
+import base64
+import io
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+import requests
+
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+SILICONFLOW_BASE = "https://api.siliconflow.cn/v1"
+ZHIPU_BASE = "https://open.bigmodel.cn/api/paas/v4"
+
+
+class AIError(RuntimeError):
+    pass
+
+
+def _env_clean(name: str) -> str | None:
+    """env value with whitespace and stray surrounding quotes removed.
+
+    setx / cmd `set VAR="value"` tend to store the quotes literally; sending
+    `Bearer "sk-..."` fails auth, so every key/base-url read goes through here.
+    """
+    v = os.environ.get(name)
+    if v is None:
+        return None
+    v = v.strip().strip('"').strip("'").strip()
+    return v or None
+
+
+def siliconflow_key() -> str | None:
+    return _env_clean("SILICONFLOW_API_KEY")
+
+
+def zhipu_key() -> str | None:
+    return _env_clean("ZHIPU_API_KEY") or _env_clean("BIGMODEL_API_KEY")
+
+
+def dashscope_key() -> str | None:
+    return _env_clean("DASHSCOPE_API_KEY")
+
+
+def openai_gateway() -> tuple[str, str] | None:
+    """Explicit trip gateway (highest priority), then the generic OPENAI_* one."""
+    base = _env_clean("TRIP_AI_BASE_URL")
+    key = _env_clean("TRIP_AI_API_KEY")
+    if base and key:
+        return base.rstrip("/"), key
+    base = _env_clean("OPENAI_BASE_URL")
+    key = _env_clean("OPENAI_API_KEY")
+    if base and key:
+        return base.rstrip("/"), key
+    return None
+
+
+def _data_url(image_path: str | Path, max_side: int = 1536, quality: int = 90) -> str:
+    """Image as a JPEG data URL (downscaled so payloads stay small)."""
+    from imquality import downscale, load_rgb
+
+    img = downscale(load_rgb(image_path), max_side)
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=quality)
+    return "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode()
+
+
+def _api_error(resp: requests.Response, tag: str) -> AIError:
+    try:
+        data = resp.json()
+    except ValueError:
+        return AIError(f"[{tag}] HTTP {resp.status_code}: {resp.text[:300]}")
+    msg = None
+    if isinstance(data, dict):
+        err = data.get("error")
+        if isinstance(err, dict):
+            msg = err.get("message")
+        msg = msg or data.get("message") or data.get("msg")
+    text = msg or str(data)[:300]
+    low = text.lower()
+    hint = ""
+    if "cooling down" in low or "cooldown" in low:
+        hint = "（网关账号池冷却中：稍等恢复，或用 TRIP_*_MODEL 换其他在售模型）"
+    elif "auth_unavailable" in low:
+        hint = "（网关侧凭据耗尽：需要到网关后台刷新该供应商授权后重试）"
+    elif resp.status_code == 403:
+        hint = "（当前 key 对该模型无权限：换模型或检查网关授权）"
+    return AIError(f"[{tag}] HTTP {resp.status_code}: {text[:300]}{hint}")
+
+
+def _extract_image_bytes(data: dict, tag: str) -> bytes:
+    """SiliconFlow returns images[].url; OpenAI-style may be data[].url/b64_json."""
+    for arr_key in ("images", "data"):
+        arr = data.get(arr_key)
+        if isinstance(arr, list) and arr:
+            item = arr[0]
+            if isinstance(item, dict):
+                if item.get("url"):
+                    img = requests.get(item["url"], timeout=120)
+                    img.raise_for_status()
+                    return img.content
+                if item.get("b64_json"):
+                    return base64.b64decode(item["b64_json"])
+    raise AIError(f"[{tag}] no image url/b64 in response: {str(data)[:300]}")
+
+
+class OpenAICompat:
+    """Any OpenAI-style endpoint: SiliconFlow, one-api/new-api gateways, vLLM..."""
+
+    name = "openai-compat"
+
+    def __init__(self, base_url: str, api_key: str, size_param: str = "image_size",
+                 multipart_edit: bool = False):
+        self.base = base_url.rstrip("/")
+        self.key = api_key
+        self.size_param = size_param  # siliconflow: image_size, zhipu: size
+        # gpt-image series over a pass-through gateway: native OpenAI protocol,
+        # i.e. multipart file upload to /images/edits (JSON data-URL is not accepted)
+        self.multipart_edit = multipart_edit
+
+    # -- internals -----------------------------------------------------------
+    def _post(self, path: str, body: dict, tag: str, timeout: int = 180) -> dict:
+        last_exc: Exception | None = None
+        last_resp: requests.Response | None = None
+        for attempt in range(3):
+            try:
+                resp = requests.post(
+                    f"{self.base}{path}",
+                    headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"},
+                    json=body,
+                    timeout=timeout,
+                )
+                if resp.status_code != 200:
+                    # 网关服务器瞬态错误(502/503/504)与网关限流 429 提示重试
+                    if resp.status_code in (502, 503, 504) and attempt < 2:
+                        last_resp = resp
+                        time.sleep(4 * (attempt + 1))
+                        continue
+                    raise _api_error(resp, tag)
+                return resp.json()
+            except (requests.ConnectionError, requests.Timeout) as exc:
+                # 本地代理(如 Clash 系列)对大图上传偶尔 10054 重置时可自动重试
+                last_exc = exc
+                if attempt < 2:
+                    time.sleep(4 * (attempt + 1))
+        # requests 失败时尝试 curl 兜底
+        try:
+            return self._post_curl(path, body, tag, timeout)
+        except AIError:
+            pass
+        if last_resp is not None:
+            raise _api_error(last_resp, tag)
+        raise AIError(f"[{tag}] 3次重试后连接依然失败: {last_exc}")
+
+    def _post_curl(self, path: str, body: dict, tag: str, timeout: int) -> dict:
+        """curl transport fallback: same JSON POST via the curl binary."""
+        import shutil as _sh
+        import subprocess as _sp
+        if not _sh.which("curl"):
+            raise AIError(f"[{tag}] curl 不可用")
+        try:
+            r = _sp.run(
+                ["curl", "-s", "-m", str(timeout), f"{self.base}{path}",
+                 "-H", f"Authorization: Bearer {self.key}",
+                 "-H", "Content-Type: application/json",
+                 "--data-binary", "@-", "-w", "\n%{http_code}"],
+                input=json.dumps(body), capture_output=True, text=True,
+                timeout=timeout + 30)
+        except _sp.SubprocessError as exc:
+            raise AIError(f"[{tag}] curl 回退调用失败: {exc}") from exc
+        text = r.stdout.rstrip()
+        status, _, payload = text.rpartition("\n")
+        if status.strip() != "200":
+            raise AIError(f"[{tag}] curl 回退 HTTP {status.strip()}: {payload[:200]}")
+        try:
+            return json.loads(payload)
+        except ValueError as exc:
+            raise AIError(f"[{tag}] curl 回退返回非合规 JSON: {exc}") from exc
+
+    @staticmethod
+    def _save(content: bytes, out_path: str | Path) -> Path:
+        out = Path(out_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_bytes(content)
+        return out
+
+    # -- public API ----------------------------------------------------------
+    def chat_vision(self, data_urls: list[str], prompt: str,
+                    model: str | None = None, timeout: int = 180) -> str:
+        content = [{"type": "image_url", "image_url": {"url": u}} for u in data_urls]
+        content.append({"type": "text", "text": prompt})
+        data = self._post("/chat/completions", {
+            "model": model, "messages": [{"role": "user", "content": content}],
+            "temperature": 0.2,
+        }, "vision", timeout)
+        try:
+            return data["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, TypeError):
+            raise AIError(f"[vision] 视觉接口返回异常响应: {str(data)[:300]}")
+
+    def text_to_image(self, prompt: str, out_path: str | Path, model: str | None = None,
+                      image_size: str = "1024x1024") -> Path:
+        if model and "gemini" in model.lower() and "image" in model.lower():
+            # gemini image models are chat-only on gateways that reject /images/*
+            data = self._post("/chat/completions", {
+                "model": model, "messages": [{"role": "user", "content": prompt}],
+            }, "t2i", timeout=300)
+            return self._save_data_uri_image(data, "t2i", out_path)
+        body = {"model": model, "prompt": prompt, self.size_param: image_size}
+        data = self._post("/images/generations", body, "t2i")
+        return self._save(_extract_image_bytes(data, "t2i"), out_path)
+
+    @staticmethod
+    def _save_data_uri_image(data: dict, tag: str, out_path: str | Path) -> Path:
+        """Pull a data:image/...;base64 URI out of an arbitrary reply JSON."""
+        import re
+
+        m = re.search(r"data:image/[a-zA-Z.+-]+;base64,([A-Za-z0-9+/=]+)", json.dumps(data))
+        if not m:
+            raise AIError(f"[{tag}] 返回中未找到图像 Base64 数据: {str(data)[:300]}")
+        return OpenAICompat._save(base64.b64decode(m.group(1)), out_path)
+
+    def edit_image(self, image_path: str | Path, prompt: str, out_path: str | Path,
+                   model: str | None = None, image_size: str | None = None) -> Path:
+        if self.multipart_edit:
+            return self._edit_multipart(image_path, prompt, out_path, model, image_size)
+        if model and "gemini" in model.lower() and "image" in model.lower():
+            # Gemini image models are chat-only: image in, image out (data URI inside reply).
+            return self._edit_gemini_chat(image_path, prompt, out_path, model)
+        body = {"model": model, "prompt": prompt, "image": _data_url(image_path)}
+        if image_size:
+            body[self.size_param] = image_size
+        data = self._post("/images/generations", body, "edit", timeout=300)
+        return self._save(_extract_image_bytes(data, "edit"), out_path)
+
+    def _edit_gemini_chat(self, image_path: str | Path, prompt: str, out_path: str | Path,
+                          model: str | None) -> Path:
+        # 图片在前、提示词在后，并强调输出图片，防止部分 gemini 渠道只回复文字
+        content = [
+            {"type": "image_url", "image_url": {"url": _data_url(image_path)}},
+            {"type": "text", "text": prompt + "\n\n直接输出编辑后的高质量图片，禁止只回复文字说明。"},
+        ]
+        data = self._post("/chat/completions", {
+            "model": model, "messages": [{"role": "user", "content": content}],
+        }, "gemini-edit", timeout=300)
+        return self._save_data_uri_image(data, "gemini-edit", out_path)
+
+    def _edit_multipart(self, image_path: str | Path, prompt: str, out_path: str | Path,
+                        model: str | None, image_size: str | None) -> Path:
+        """Native OpenAI gpt-image editing: multipart POST /images/edits."""
+        src = Path(image_path)
+        mime = "image/png" if src.suffix.lower() == ".png" else "image/jpeg"
+        fields = {"model": model or "", "prompt": prompt}
+        if image_size:
+            fields["size"] = image_size
+        last_exc = None
+        for attempt in range(3):
+            try:
+                resp = requests.post(
+                    f"{self.base}/images/edits",
+                    headers={"Authorization": f"Bearer {self.key}"},
+                    files={"image": (src.name, src.read_bytes(), mime)},
+                    data=fields,
+                    timeout=300,
+                )
+                if resp.status_code != 200:
+                    raise _api_error(resp, "edit")
+                return self._save(_extract_image_bytes(resp.json(), "edit"), out_path)
+            except (requests.ConnectionError, requests.Timeout) as exc:
+                last_exc = exc
+                if attempt < 2:
+                    time.sleep(4 * (attempt + 1))
+        raise AIError(f"[edit] 3次重试后连接失败: {last_exc}")
+
+
+class Zhipu(OpenAICompat):
+    """BigModel platform: glm-4v vision (OpenAI-style) + glm-image t2i."""
+
+    name = "zhipu"
+
+    def __init__(self, api_key: str | None = None):
+        super().__init__(ZHIPU_BASE, api_key or zhipu_key() or "", size_param="size")
+
+    def edit_image(self, *args, **kwargs):
+        raise AIError(
+            "[zhipu edit] 智谱当前图像接口仅支持文生图(不支持输入图片进行修图)。\n"
+            "AI 修图请配置 SILICONFLOW_API_KEY (Qwen-Image-Edit) 或\n"
+            "DASHSCOPE_API_KEY (wanx2.1-imageedit)。详见 references/api-config.md。"
+        )
+
+
+class Dashscope:
+    """Aliyun Bailian wanx2.1-imageedit: preset edit functions, async two-step API."""
+
+    BASE = "https://dashscope.aliyuncs.com/api/v1"
+    FUNCTIONS = {
+        "edit": "description_edit",
+        "erase": "erase_anything",
+        "expand": "expansion",
+        "style": "style_repaint",
+        "colorize": "colorization",
+        "upscale": "image_ultra_quality",
+    }
+
+    def __init__(self, key: str | None = None):
+        self.key = key or dashscope_key()
+        if not self.key:
+            raise AIError(
+                "[missing key] 请先配置 DASHSCOPE_API_KEY (bailian.console.aliyun.com)。\n"
+                "或使用 OpenAI 兼容服务商: 配置 SILICONFLOW_API_KEY (Qwen-Image-Edit)。\n"
+                "详见 references/api-config.md。"
+            )
+
+    def edit_image(self, image_path: str | Path, prompt: str, out_path: str | Path,
+                   function: str = "description_edit", model: str = "wanx2.1-imageedit",
+                   timeout: int = 300) -> Path:
+        real = self.FUNCTIONS.get(function, function)
+        resp = requests.post(
+            f"{self.BASE}/services/aigc/image2image/image-synthesis",
+            headers={
+                "Authorization": f"Bearer {self.key}",
+                "Content-Type": "application/json",
+                "X-DashScope-Async": "enable",
+            },
+            json={
+                "model": model,
+                "input": {"function": real, "prompt": prompt, "base_image_url": _data_url(image_path)},
+                "parameters": {},
+            },
+            timeout=60,
+        )
+        data = resp.json()
+        if resp.status_code != 200 or "output" not in data:
+            raise _api_error(resp, "dashscope submit")
+        task_id = data["output"]["task_id"]
+
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            time.sleep(2.5)
+            poll = requests.get(
+                f"{self.BASE}/tasks/{task_id}",
+                headers={"Authorization": f"Bearer {self.key}"},
+                timeout=30,
+            ).json()
+            status = poll.get("output", {}).get("task_status")
+            if status == "SUCCEEDED":
+                content = _extract_image_bytes(poll["output"], f"dashscope task {task_id}")
+                return self._save(content, out_path)
+            if status in ("FAILED", "CANCELED", "UNKNOWN"):
+                raise AIError(f"[dashscope task {task_id}] {status}: "
+                              f"{poll.get('output', {}).get('message', poll)}")
+        raise AIError(f"[dashscope task {task_id}] 任务超过 {timeout} 秒超时")
+
+    _save = staticmethod(OpenAICompat._save)
+
+
+# --- provider factories ------------------------------------------------------
+MODEL_ENV = {"vision": "TRIP_VL_MODEL", "edit": "TRIP_EDIT_MODEL", "t2i": "TRIP_T2I_MODEL"}
+DEFAULTS = {
+    "vision-sf": "zai-org/GLM-4.5V",
+    "vision-zp": "glm-4v-flash",
+    "edit-sf": "Qwen/Qwen-Image-Edit-2509",
+    "t2i-sf": "Kwai-Kolors/Kolors",
+    "t2i-zp": "glm-image",
+}
+
+# 网关模型自动挑选：TRIP_*_MODEL 未指定时，从网关 /models 在售列表中按偏好筛选
+# 核心原则：OpenAI 兼容协议统一接入；对话模型本身能识图+生图（如 gemini 图像系/gpt-image 系）时，
+# VL/EDIT/T2I 全部就地解决，不需要配置额外模型。
+_VISION_PREF = ["gemini-3.8-flash-high", "gemini-3.7-flash-high", "gemini-3.6-flash-high",
+                "gemini-3-flash-preview", "claude-sonnet-4-6", "gpt-5.6-sol", "gpt-5.5"]
+_IMAGE_PREF = ["gemini-3.1-flash-image", "gpt-image-2", "gpt-image-1.5"]
+
+_MODELS_CACHE: dict[str, list[str]] = {}
+
+
+def _gateway_models(base: str, key: str) -> list[str]:
+    """GET /models with a per-base cache; empty list on any failure."""
+    if base not in _MODELS_CACHE:
+        ids: list[str] = []
+        for attempt in range(3):
+            try:
+                resp = requests.get(f"{base.rstrip('/')}/models",
+                                    headers={"Authorization": f"Bearer {key}"}, timeout=10)
+                if resp.status_code == 200:
+                    ids = [m.get("id", "") for m in resp.json().get("data", [])]
+                break
+            except requests.RequestException:
+                if attempt < 2:
+                    time.sleep(2 * (attempt + 1))
+        _MODELS_CACHE[base] = ids
+    return _MODELS_CACHE[base]
+
+
+def _pick_model(kind: str, base: str, key: str, fallback: str) -> str:
+    """Auto-pick a model for kind (vision|edit|t2i) from the gateway's own list."""
+    override = _env_clean(MODEL_ENV[kind])
+    if override:
+        return override
+    pref = _VISION_PREF if kind == "vision" else _IMAGE_PREF
+    avail = set(_gateway_models(base, key))
+    for m in pref:
+        if m in avail:
+            return m
+    return pref[0] if not avail else fallback
+
+
+def _size_param_for(model: str | None) -> str:
+    """Name of the image-size request parameter for a given model."""
+    override = _env_clean("TRIP_SIZE_PARAM")
+    if override:
+        return override
+    if model and "gpt-image" in model.lower():
+        return "size"
+    return "image_size"
+
+
+def _env_model(kind: str, fallback: str) -> str:
+    return _env_clean(MODEL_ENV[kind]) or fallback
+
+
+MISSING_KEY_HELP = (
+    "[missing key] 未配置任何 AI 服务商 key。可选方案（任选其一即可）：\n"
+    "  1. 自建网关: TRIP_AI_BASE_URL + TRIP_AI_API_KEY (推荐，识图+修图+海报全覆盖)\n"
+    "  2. 硅基流动: SILICONFLOW_API_KEY (siliconflow.cn - 识图+修图+生图全覆盖)\n"
+    "  3. 智谱 AI: ZHIPU_API_KEY (bigmodel.cn - 识图评分+生图)\n"
+    "  4. 阿里百炼: DASHSCOPE_API_KEY (bailian.console.aliyun.com - 独家扩图/超分)\n"
+    "详见 trip-moments 技能 references/api-config.md 指南。"
+)
+
+
+def vision_client():
+    """(client, model) for image scoring; raises AIError if nothing configured."""
+    gateway = openai_gateway()
+    if gateway:
+        return (OpenAICompat(gateway[0], gateway[1]),
+                _pick_model("vision", gateway[0], gateway[1], DEFAULTS["vision-sf"]))
+    if siliconflow_key():
+        return (OpenAICompat(SILICONFLOW_BASE, siliconflow_key()),
+                _env_model("vision", DEFAULTS["vision-sf"]))
+    if zhipu_key():
+        return (Zhipu(), _env_model("vision", DEFAULTS["vision-zp"]))
+    raise AIError(MISSING_KEY_HELP)
+
+
+def t2i_client():
+    """(client, model, image_size) for text-to-image (poster panel)."""
+    gateway = openai_gateway()
+    if gateway:
+        model = _pick_model("t2i", gateway[0], gateway[1], DEFAULTS["t2i-sf"])
+        return (OpenAICompat(gateway[0], gateway[1], size_param=_size_param_for(model)),
+                model, "1024x1024")
+    if siliconflow_key():
+        return (OpenAICompat(SILICONFLOW_BASE, siliconflow_key()),
+                _env_model("t2i", DEFAULTS["t2i-sf"]), "1024x1024")
+    if zhipu_key():
+        return (Zhipu(), _env_model("t2i", DEFAULTS["t2i-zp"]), "1280x1280")
+    raise AIError(MISSING_KEY_HELP)
+
+
+def edit_client(prefer: str = "auto"):
+    """(client, model, kind) for image editing; kind: dashscope|openai."""
+    gateway = openai_gateway()
+    if prefer in ("auto", "dashscope") and dashscope_key():
+        return Dashscope(), "wanx2.1-imageedit", "dashscope"
+    if prefer in ("auto", "openai") and gateway:
+        model = _pick_model("edit", gateway[0], gateway[1], DEFAULTS["edit-sf"])
+        return (OpenAICompat(gateway[0], gateway[1], size_param=_size_param_for(model),
+                             multipart_edit="gpt-image" in model.lower()),
+                model, "openai")
+    if prefer in ("auto", "openai") and siliconflow_key():
+        return (OpenAICompat(SILICONFLOW_BASE, siliconflow_key()),
+                _env_model("edit", DEFAULTS["edit-sf"]), "openai")
+    raise AIError(MISSING_KEY_HELP)
+
+
+def face_integrity_check(original: str | Path, edited: str | Path) -> dict | None:
+    """Compare an AI-edited photo against its original with the vision model."""
+    try:
+        client, model = vision_client()
+    except AIError:
+        return None
+    prompt = ("第一张是原图，第二张是 AI 编辑后的成图。请仔细对比面部与人物，只输出 JSON:\n"
+              '{"has_person": 布尔值(原图是否有清晰人物), "same_person": 编辑后是否仍为同一人, '
+              '"distorted": 面部或肢体是否存在明显畸变/崩脸/假指, "note": "<=15字说明"}')
+    try:
+        reply = client.chat_vision(
+            [_data_url(original, max_side=768), _data_url(edited, max_side=768)],
+            prompt, model=model)
+        data = json_from_reply(reply)
+        return data if isinstance(data, dict) else None
+    except (AIError, ValueError):
+        return None
+
+
+def json_from_reply(text: str):
+    """Best-effort JSON extraction from a model reply (handles ``` fences, <think>)."""
+    import json
+    import re
+
+    text = re.sub(r"<think>.*?</think>", "", text, flags=re.S)
+    text = re.sub(r"```(?:json)?", "", text).strip()
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        for open_ch, close_ch in (("[", "]"), ("{", "}")):
+            start, end = text.find(open_ch), text.rfind(close_ch)
+            if start != -1 and end > start:
+                try:
+                    return json.loads(text[start : end + 1])
+                except json.JSONDecodeError:
+                    continue
+        raise AIError(f"[vision] 无法从模型返回中提取有效 JSON: {text[:300]}")

package/.agents/skills/trip-moments/scripts/check_env.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Environment self-check for the trip-moments skill.
+
+Run once per session (or after changing keys) BEFORE any AI feature:
+
+  python check_env.py
+
+Checks, in order:
+  1. Python dependencies importable (numpy / PIL / requests)
+  2. Provider environment keys configuration
+  3. Live gateway model accessibility and validity:
+     - gateway (TRIP_AI_* / OPENAI_*): compares TRIP_VL_MODEL / TRIP_EDIT_MODEL /
+       TRIP_T2I_MODEL against live GET /v1/models list
+     - SiliconFlow: live model availability probe
+  4. AMAP_KEY presence (route-map only)
+
+Exit code 0 = clean, 1 = at least one model mismatch or missing dependency.
+Read-only: never calls billed endpoints.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+MODEL_ENVS = ("TRIP_VL_MODEL", "TRIP_EDIT_MODEL", "TRIP_T2I_MODEL")
+KEY_ENVS = ("TRIP_AI_BASE_URL", "TRIP_AI_API_KEY", "OPENAI_BASE_URL", "OPENAI_API_KEY",
+            "SILICONFLOW_API_KEY", "ZHIPU_API_KEY", "DASHSCOPE_API_KEY", "AMAP_KEY")
+ISSUES: list[str] = []
+
+
+def _clean(v: str | None) -> str:
+    return (v or "").strip().strip('"').strip("'").strip()
+
+
+def check_deps() -> None:
+    print("[运行环境依赖]")
+    for mod in ("numpy", "PIL", "requests"):
+        try:
+            __import__(mod)
+            print(f"  [ok]  {mod}")
+        except ImportError:
+            ISSUES.append(f"缺失必要依赖 {mod}，请在终端执行: python -m pip install -r requirements.txt")
+            print(f"  [MISSING] {mod}")
+
+
+def check_provider_models(base: str, key: str, model_envs: dict[str, str], label: str) -> None:
+    import requests
+
+    try:
+        resp = requests.get(f"{base.rstrip('/')}/models",
+                            headers={"Authorization": f"Bearer {key}"},
+                            timeout=(8, 15))
+        resp.raise_for_status()
+        available = {m.get("id", "") for m in resp.json().get("data", [])}
+    except Exception as exc:
+        print(f"  [warn] {label} /models 查询失败 ({type(exc).__name__})，跳过动态在售比对")
+        return
+    print(f"  [ok]  {label} 连通正常，可用模型数: {len(available)}")
+    for env, model in model_envs.items():
+        if model in available:
+            print(f"  [ok]  {env} = {model}")
+        else:
+            ISSUES.append(f"{env}={model} 不在该 {label} 提供的模型列表中 -> setx {env} \"<有效模型名>\"")
+            print(f"  [MISMATCH] {env} = {model} (不在 {label} 在售列表)")
+
+
+def main() -> int:
+    check_deps()
+
+    print("[API 密钥配置]")
+    env = {k: _clean(os.environ.get(k)) for k in KEY_ENVS}
+    for k in KEY_ENVS:
+        if env[k]:
+            masked = env[k][:6] + "..." + env[k][-4:] if len(env[k]) > 12 else "***"
+            print(f"  [set] {k} = {masked}")
+    if not any(env[k] for k in KEY_ENVS[:-1]):
+        print("  [info] 未配置任何云端 AI 密钥（本地功能全可用，云端 AI 选图/修图/生图将跳过）")
+
+    print("[模型参数配置]")
+    model_envs = {e: _clean(os.environ.get(e)) for e in MODEL_ENVS if _clean(os.environ.get(e))}
+
+    gw_base, gw_key = env["TRIP_AI_BASE_URL"], env["TRIP_AI_API_KEY"]
+    if not (gw_base and gw_key):
+        gw_base, gw_key = env["OPENAI_BASE_URL"], env["OPENAI_API_KEY"]
+    if gw_base and gw_key:
+        check_provider_models(gw_base, gw_key, model_envs, "AI自建网关")
+    elif model_envs:
+        print("  [warn] 设定了 TRIP_*_MODEL 但未配置对应网关 Base URL")
+
+    if env["SILICONFLOW_API_KEY"] and not (gw_base and gw_key):
+        check_provider_models("https://api.siliconflow.cn/v1", env["SILICONFLOW_API_KEY"],
+                              model_envs, "SiliconFlow")
+
+    print("[高德地图 API]")
+    if env["AMAP_KEY"]:
+        print("  [ok]  AMAP_KEY 已配置 (支持高德静态旅行路线图生成)")
+    if ISSUES:
+        print("\n[待处理事项 / Issues]")
+        for i in ISSUES:
+            print(f"  - {i}")
+        print("修改环境变量后请新开终端重试确认。")
+        return 1
+    print("\n[ok] 环境检查通过！")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())