polyclaude 0.4.2__tar.gz → 0.4.4__tar.gz

{polyclaude-0.4.2 → polyclaude-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: polyclaude
-Version: 0.4.2
+Version: 0.4.4
 Summary: Use OpenAI, Gemini, and any OpenAI-compatible model inside the Claude Code CLI.
 Project-URL: Homepage, https://github.com/ibedevesh/polyclaude
 Project-URL: Repository, https://github.com/ibedevesh/polyclaude
@@ -86,6 +86,7 @@ polyclaude --gemini -- -p "explain this repo"
 | OpenAI | `--openai` | `OPENAI_API_KEY` | `gpt-4.1` |
 | Moonshot Kimi | `--kimi` (or `--moonshot`) | `MOONSHOT_API_KEY` | `kimi-k3.1-pro` |
 | DeepSeek | `--deepseek` | `DEEPSEEK_API_KEY` | `deepseek-flash` |
+| Z.ai GLM | `--glm` (or `--zai`) | `ZAI_API_KEY` | `glm-5.3` |
 | Groq | `--groq` | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
 | OpenRouter | `--openrouter` | `OPENROUTER_API_KEY` | `anthropic/claude-3.5-sonnet` |
 | Ollama (local) | `--ollama` | — | `qwen2.5-coder` |
@@ -111,6 +112,8 @@ calling and reasoning keep working:
   `kimi-k2.6`) work via `--model`.
 - Reasoning models reject non-default sampling params — dropped automatically.
 - Turns that hit the output-token cap are transparently continued.
+- A deep-thinking turn on a long context can take minutes, so the bridge waits
+  up to 600s for the backend. Raise or lower it with `--timeout SECONDS`.
 
 Run `polyclaude --list` to see everything.
 

{polyclaude-0.4.2 → polyclaude-0.4.4}/README.md

@@ -65,6 +65,7 @@ polyclaude --gemini -- -p "explain this repo"
 | OpenAI | `--openai` | `OPENAI_API_KEY` | `gpt-4.1` |
 | Moonshot Kimi | `--kimi` (or `--moonshot`) | `MOONSHOT_API_KEY` | `kimi-k3.1-pro` |
 | DeepSeek | `--deepseek` | `DEEPSEEK_API_KEY` | `deepseek-flash` |
+| Z.ai GLM | `--glm` (or `--zai`) | `ZAI_API_KEY` | `glm-5.3` |
 | Groq | `--groq` | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
 | OpenRouter | `--openrouter` | `OPENROUTER_API_KEY` | `anthropic/claude-3.5-sonnet` |
 | Ollama (local) | `--ollama` | — | `qwen2.5-coder` |
@@ -90,6 +91,8 @@ calling and reasoning keep working:
   `kimi-k2.6`) work via `--model`.
 - Reasoning models reject non-default sampling params — dropped automatically.
 - Turns that hit the output-token cap are transparently continued.
+- A deep-thinking turn on a long context can take minutes, so the bridge waits
+  up to 600s for the backend. Raise or lower it with `--timeout SECONDS`.
 
 Run `polyclaude --list` to see everything.
 

{polyclaude-0.4.2 → polyclaude-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "polyclaude"
-version = "0.4.2"
+version = "0.4.4"
 description = "Use OpenAI, Gemini, and any OpenAI-compatible model inside the Claude Code CLI."
 readme = "README.md"
 license = { text = "MIT" }

{polyclaude-0.4.2 → polyclaude-0.4.4}/src/polyclaude/__init__.py

@@ -1,3 +1,3 @@
 """polyclaude — use OpenAI, Gemini, and any OpenAI-compatible model in Claude Code."""
 
-__version__ = "0.4.2"
+__version__ = "0.4.4"

{polyclaude-0.4.2 → polyclaude-0.4.4}/src/polyclaude/bridge.py

@@ -17,6 +17,7 @@ Configured entirely via POLYCLAUDE_* environment variables (set by the CLI):
                                OpenAI uses it as-is, Kimi maps it to low|high|max
     POLYCLAUDE_AUTOCONTINUE    1 = stitch a turn truncated at the token cap
     POLYCLAUDE_MAXTOK          output cap (default 32768)
+    POLYCLAUDE_TIMEOUT         seconds to wait for a backend turn (default 600)
     POLYCLAUDE_SYSTEM_APPEND_FILE   append this file to the main system prompt
     POLYCLAUDE_SYSTEM_REPLACE_FILE  replace the main system prompt with this file
     POLYCLAUDE_LOG             optional path to a wire log
@@ -37,6 +38,10 @@ REASONING = os.environ.get("POLYCLAUDE_REASONING", "high")
 AUTOCONT = os.environ.get("POLYCLAUDE_AUTOCONTINUE", "1") == "1"
 MAX_TOK = int(os.environ.get("POLYCLAUDE_MAXTOK", "32768"))
 MAXCONT = int(os.environ.get("POLYCLAUDE_MAXCONT", "4"))
+# How long to wait for the backend to finish a turn. Thinking models (Kimi at
+# reasoning_effort=max, GPT-5.x, Gemini 3.x) routinely need minutes on a long
+# context, and the old hard-coded 120s cut them off mid-answer.
+TIMEOUT = int(os.environ.get("POLYCLAUDE_TIMEOUT", "600"))
 LOG = os.environ.get("POLYCLAUDE_LOG", "")
 
 # Moonshot (Kimi) is OpenAI-compatible but has three quirks:
@@ -51,6 +56,15 @@ KIMI = "moonshot.ai" in BASE or "kimi.ai" in BASE
 # polyclaude's low|medium|high -> Kimi's low|high|max (it has no "medium")
 _KIMI_EFFORT = {"low": "low", "medium": "high", "high": "max"}
 
+# Z.ai (GLM) is OpenAI-compatible but, like Kimi, reads `max_tokens` rather than
+# `max_completion_tokens`. GLM-5.3 always thinks (thinking.type can only be
+# "enabled") and exposes the same low|high|max effort ladder as Kimi — z.ai
+# recommends "max" for coding. Sampling is left alone for the thinking models
+# for the same reason as Kimi: the docs warn against pinning temperature and
+# top_p together, and Claude Code sends both.
+GLM = "api.z.ai" in BASE or "bigmodel.cn" in BASE
+_GLM_EFFORT = _KIMI_EFFORT
+
 # --- identity scrub / inspect -------------------------------------------------
 # POLYCLAUDE_SCRUB=1            enable rewriting of the outgoing payload
 # POLYCLAUDE_IDENTITY_MAP      "old=new,old2=new2" literal replacements, applied
@@ -349,9 +363,9 @@ def _to_openai(body):
     tgt = _pick_model(body.get("model", ""))
     cap = min(int(body.get("max_tokens", MAX_TOK)), MAX_TOK)
     out = {"model": tgt, "messages": msgs}
-    # Kimi reads max_tokens (and bills reasoning tokens against it); the
-    # OpenAI family wants max_completion_tokens.
-    out["max_tokens" if KIMI else "max_completion_tokens"] = cap
+    # Kimi reads max_tokens (and bills reasoning tokens against it), and so does
+    # z.ai; the OpenAI family wants max_completion_tokens.
+    out["max_tokens" if (KIMI or GLM) else "max_completion_tokens"] = cap
     # reasoning models (and Kimi, whose sampling is fixed server-side) reject
     # explicit temperature / top_p
     reasoning = KIMI or tgt.startswith(("gpt-5", "gpt-6", "o1", "o3", "o4"))
@@ -359,6 +373,11 @@ def _to_openai(body):
         # K3.1 Pro always thinks; only the depth is tunable. Older Kimi models
         # don't take the field at all.
         out["reasoning_effort"] = _KIMI_EFFORT.get(REASONING, "max")
+    if GLM and tgt.startswith("glm-5"):
+        # GLM-5.x thinks by default; only the depth is tunable. The -flash tiers
+        # accept the field too, so key off the family rather than the exact id.
+        out["reasoning_effort"] = _GLM_EFFORT.get(REASONING, "max")
+        reasoning = True
     if not reasoning:
         if body.get("temperature") is not None:
             out["temperature"] = body["temperature"]
@@ -466,7 +485,8 @@ def _use_responses(tgt):
 # ---------------------------------------------------------------------------
 # HTTP to the backend
 # ---------------------------------------------------------------------------
-def _post(path, payload, timeout):
+def _post(path, payload, timeout=None):
+    timeout = TIMEOUT if timeout is None else timeout
     req = urllib.request.Request(
         f"{BASE}/{path}", data=json.dumps(payload).encode(),
         headers={"Authorization": f"Bearer {API_KEY}",
@@ -479,7 +499,7 @@ def _post(path, payload, timeout):
 
 
 def _chat(payload):
-    oai = _post("chat/completions", payload, 120)
+    oai = _post("chat/completions", payload)
     if not AUTOCONT:
         return oai
     for _ in range(MAXCONT):
@@ -493,7 +513,7 @@ def _chat(payload):
             half["reasoning_content"] = msg["reasoning_content"]
         cont["messages"] = payload["messages"] + [
             half, {"role": "user", "content": "continue"}]
-        nxt = _post("chat/completions", cont, 120)
+        nxt = _post("chat/completions", cont)
         nmsg = (nxt.get("choices") or [{}])[0].get("message", {})
         oai["choices"][0]["message"]["content"] = \
             (msg.get("content") or "") + (nmsg.get("content") or "")
@@ -803,7 +823,7 @@ class Bridge:
              f"msgs={len(body.get('messages', []))} ===")
         try:
             if _use_responses(tgt):
-                oai = _responses_to_oai(_post("responses", _to_responses(body), 300))
+                oai = _responses_to_oai(_post("responses", _to_responses(body)))
                 _log(f">>> via /responses (reasoning={REASONING})")
             else:
                 oai = _chat(_to_openai(body))
@@ -816,8 +836,18 @@ class Bridge:
             _log(f"!!! backend {e.code}: {detail}")
             sse = _error_sse(model, f"backend {e.code}: {detail}")
         except Exception as e:
-            _log(f"!!! {e!r}")
-            sse = _error_sse(model, repr(e))
+            # a read timeout surfaces as TimeoutError; a connect timeout comes
+            # wrapped in URLError(reason=TimeoutError)
+            if isinstance(e, TimeoutError) or isinstance(
+                    getattr(e, "reason", None), TimeoutError):
+                _log(f"!!! timeout after {TIMEOUT}s: {e!r}")
+                sse = _error_sse(model, (
+                    f"the backend did not answer within {TIMEOUT}s. Thinking "
+                    f"models can need longer on a big context — raise it with "
+                    f"--timeout SECONDS (or POLYCLAUDE_TIMEOUT)."))
+            else:
+                _log(f"!!! {e!r}")
+                sse = _error_sse(model, repr(e))
         flow.response = http.Response.make(
             200, sse, {"content-type": "text/event-stream; charset=utf-8"})
 

{polyclaude-0.4.2 → polyclaude-0.4.4}/src/polyclaude/cli.py

@@ -199,6 +199,10 @@ def main(argv=None):
                     help="don't append the '⚠ model tried to STOP' banner")
     ap.add_argument("--reasoning", choices=["low", "medium", "high"],
                     help="OpenAI reasoning depth (default high)")
+    ap.add_argument("--timeout", type=int, default=600, metavar="SECONDS",
+                    help="how long to wait for the backend to finish a turn "
+                         "(default 600; raise it for deep-thinking models on a "
+                         "big context)")
     ap.add_argument("--hue", type=float, default=110.0,
                     help="accent hue for the branding, degrees (default 110 = green)")
     ap.add_argument("--resume", nargs="?", const="", default=None, metavar="SESSION",
@@ -276,6 +280,7 @@ def main(argv=None):
         "POLYCLAUDE_SMALL": prov["small"],
         "POLYCLAUDE_KEY": key or "none",
         "POLYCLAUDE_REASONING": args.reasoning or "high",
+        "POLYCLAUDE_TIMEOUT": str(args.timeout),
         "POLYCLAUDE_AUTOCONTINUE": "1",
         "POLYCLAUDE_LOG": log,
     })

{polyclaude-0.4.2 → polyclaude-0.4.4}/src/polyclaude/providers.py

@@ -64,6 +64,19 @@ PROVIDERS = {
         "key_env": ["DEEPSEEK_API_KEY"],
         "help": "Get a key at https://platform.deepseek.com/api_keys",
     },
+    "glm": {
+        # Z.ai (Zhipu). glm-5.3 is the flagship (1M context, 128K output,
+        # always-thinking, text-only). glm-5.3-flash is the cheap tier and takes
+        # images, so it carries the side-call slot.
+        # GLM Coding Plan subscribers have a SEPARATE key and endpoint:
+        # POLYCLAUDE_BASE=https://api.z.ai/api/coding/paas/v4
+        "base": "https://api.z.ai/api/paas/v4",
+        "model": "glm-5.3",
+        "small": "glm-5.3-flash",
+        "key_env": ["ZAI_API_KEY", "GLM_API_KEY", "ZHIPUAI_API_KEY"],
+        "aliases": ["zai"],
+        "help": "Get a key at https://z.ai/manage-apikey/apikey-list",
+    },
     "ollama": {
         "base": "http://127.0.0.1:11434/v1",
         "model": "qwen2.5-coder",