openclaw
01d8562fce
GLM-5.3 is live on api.z.ai (coding plan endpoint) but had no entries in Hermes, so it silently fell back to the generic 202K GLM context — triggering premature context compression on a 1M-window model. - model_metadata: 'glm-5.3': 1_048_576 (same base model as 5.2; 1M context / 128K max output per docs.z.ai/guides/llm/glm-5.3, verified 2026-08-14) - auth: add glm-5.3 to coding-plan probe lists (global + CN) - models: add glm-5.3 to picker/model lists (6 sites) - zai provider: reasoning_effort mapping covers glm-5.3 (accepted live by the endpoint, HTTP 200)
138 lines
5.2 KiB
Python
138 lines
5.2 KiB
Python
"""ZAI / GLM provider profile.
|
|
|
|
Z.AI's GLM-4.5-and-later chat models default to thinking-mode ON when the
|
|
request omits ``thinking``. Hermes' ``reasoning_config = {"enabled": False}``
|
|
was previously a silent no-op on this route — the base profile emits nothing,
|
|
so users who turned thinking off (desktop toggle, ``/reasoning none``,
|
|
``reasoning_effort: none``/``false`` in config.yaml) kept burning thinking
|
|
tokens on every turn.
|
|
|
|
:meth:`ZaiProfile.build_api_kwargs_extras` translates the Hermes reasoning
|
|
config into the wire shape Z.AI's OpenAI-compat endpoint expects:
|
|
|
|
{"extra_body": {"thinking": {"type": "enabled" | "disabled"}}}
|
|
|
|
When no reasoning preference is set (``reasoning_config is None``) the field
|
|
is omitted so the server default applies, matching prior behavior. GLM
|
|
models before 4.5 (e.g. ``glm-4-9b``) don't accept ``thinking`` and are left
|
|
untouched.
|
|
|
|
GLM-5.2 additionally exposes a native ``reasoning_effort`` knob with exactly
|
|
two enabled levels — ``high`` and ``max`` — on the OpenAI-compatible endpoint
|
|
(per Z.AI / BigModel docs). Hermes' richer effort scale is collapsed onto
|
|
those two so the user's effort preference actually reaches the model instead
|
|
of being silently dropped.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from typing import Any
|
|
|
|
from providers import register_provider
|
|
from providers.base import ProviderProfile
|
|
|
|
_GLM_VERSION_RE = re.compile(r"^glm-(\d+)(?:\.(\d+))?")
|
|
|
|
|
|
def _model_supports_thinking(model: str | None) -> bool:
|
|
"""GLM thinking-capable model families: glm-4.5 and later (4.5, 4.6, 5…)."""
|
|
m = (model or "").strip().lower()
|
|
match = _GLM_VERSION_RE.match(m)
|
|
if not match:
|
|
return False
|
|
major = int(match.group(1))
|
|
minor = int(match.group(2) or 0)
|
|
return (major, minor) >= (4, 5)
|
|
|
|
|
|
def _is_glm_5_2(model: str | None) -> bool:
|
|
"""Detect GLM-5.2/5.3 (reasoning_effort-capable) across alias spellings.
|
|
|
|
Covers the canonical ``glm-5.2``/``glm-5.3`` plus the ``glm-5-2`` /
|
|
``glm-5p2`` variants seen on relays (Fireworks ``glm-5p2``, etc.) and any
|
|
vendor-prefixed form (``z-ai/glm-5.2``, ``zai-org-glm-5-2``). GLM-5.3
|
|
uses the same base model as 5.2 (post-training gains only) and exposes
|
|
the same ``reasoning_effort`` knob (verified live 2026-08-14: the
|
|
coding-plan endpoint accepts ``reasoning_effort: high`` for glm-5.3).
|
|
"""
|
|
m = (model or "").strip().lower()
|
|
if not m:
|
|
return False
|
|
return any(
|
|
token in m
|
|
for token in ("glm-5.2", "glm-5-2", "glm-5p2", "glm-5.3", "glm-5-3", "glm-5p3")
|
|
)
|
|
|
|
|
|
def _glm_5_2_reasoning_effort(reasoning_config: dict | None) -> str | None:
|
|
"""Map Hermes reasoning effort onto GLM-5.2/5.3's native ``high``/``max``.
|
|
|
|
These models only support two enabled effort levels. ``xhigh``/``max``/``ultra``
|
|
request the top tier; everything else that is enabled requests ``high``
|
|
(its minimum thinking level). When reasoning is explicitly disabled, or
|
|
no effort preference is supplied, the server default is left untouched.
|
|
"""
|
|
if not isinstance(reasoning_config, dict):
|
|
return None
|
|
if reasoning_config.get("enabled") is False:
|
|
return None
|
|
|
|
effort = (reasoning_config.get("effort") or "").strip().lower()
|
|
if not effort or effort == "none":
|
|
return None
|
|
|
|
# GLM-5.2's two-level vocabulary (high = its minimum thinking level,
|
|
# max = top tier) is declared in agent.reasoning_effort; xhigh rounds up
|
|
# to max. Everything at or below high clamps to high — GLM cannot think
|
|
# less than that.
|
|
from agent.reasoning_effort import GLM52_EFFORTS, GLM52_OVERRIDES, clamp_effort
|
|
|
|
clamped = clamp_effort(effort, GLM52_EFFORTS, GLM52_OVERRIDES)
|
|
return clamped if clamped in GLM52_EFFORTS else "high"
|
|
|
|
|
|
class ZaiProfile(ProviderProfile):
|
|
"""Z.AI / GLM — extra_body.thinking on/off + GLM-5.2 reasoning_effort."""
|
|
|
|
def build_api_kwargs_extras(
|
|
self, *, reasoning_config: dict | None = None, model: str | None = None, **context
|
|
) -> tuple[dict[str, Any], dict[str, Any]]:
|
|
extra_body: dict[str, Any] = {}
|
|
top_level: dict[str, Any] = {}
|
|
|
|
if not _model_supports_thinking(model) and not _is_glm_5_2(model):
|
|
return extra_body, top_level
|
|
|
|
# Only emit when the user expressed a preference; omitting the field
|
|
# keeps the server default (enabled) exactly as before.
|
|
if isinstance(reasoning_config, dict):
|
|
enabled = reasoning_config.get("enabled") is not False
|
|
extra_body["thinking"] = {"type": "enabled" if enabled else "disabled"}
|
|
|
|
if _is_glm_5_2(model):
|
|
effort = _glm_5_2_reasoning_effort(reasoning_config)
|
|
if effort is not None:
|
|
top_level["reasoning_effort"] = effort
|
|
|
|
return extra_body, top_level
|
|
|
|
|
|
zai = ZaiProfile(
|
|
name="zai",
|
|
aliases=("glm", "z-ai", "z.ai", "zhipu"),
|
|
env_vars=("GLM_API_KEY", "ZAI_API_KEY", "Z_AI_API_KEY"),
|
|
display_name="Z.AI (GLM)",
|
|
description="Z.AI / GLM — Zhipu AI models",
|
|
signup_url="https://z.ai/",
|
|
fallback_models=(
|
|
"glm-5.2",
|
|
"glm-5",
|
|
"glm-4-9b",
|
|
),
|
|
base_url="https://api.z.ai/api/paas/v4",
|
|
default_aux_model="glm-4.5-flash",
|
|
)
|
|
|
|
register_provider(zai)
|