[ENHANCEMENT] Add support for GLM-4.7 on Z.ai Provider

[mdziekon]

Problem (one or two sentences)

It appears Z.ai dropped GLM-4.7 (https://docs.z.ai/guides/llm/glm-4.7) which is already available via Chat & API (available in their Coding plan). This new model is not yet available via the Z.ai Provider's models list, so I assume it has to be added manually in the Roo's definitions for this provider.

Please add basic support for this model. I think it adds thinking capabilities, but for now even basic support would be great.

Context (who is affected and when)

All users of Z.ai Provider who wish to test out & use new GLM-4.7 model

Desired behavior (conceptual, not technical)

GLM-4.7 model is available to be picked from the Provider's models list

Constraints / preferences (optional)

No response

Request checklist

• I've searched existing Issues and Discussions for duplicates
• This describes a specific problem with clear context and impact

Roo Code Task Links (optional)

No response

Acceptance criteria (optional)

No response

Proposed approach (optional)

No response

Trade-offs / risks (optional)

No response

I have analyzed this issue and here is my proposed implementation plan:

Proposed Changes

Add GLM-4.7 model support to the Z.ai provider by updating packages/types/src/providers/zai.ts:

1. Add glm-4.7 to internationalZAiModels with the following configuration (based on the Z.ai GLM-4.7 documentation):

   • maxTokens: 98,304
   • contextWindow: 200,000 (matching GLM-4.6 pattern)
   • supportsImages: false
   • supportsPromptCache: true
   • supportsNativeTools: true
   • defaultToolProtocol: "native"
   • Pricing from Z.ai pricing page
   • Description highlighting the model's new capabilities

2. Add glm-4.7 to mainlandZAiModels with similar configuration but using mainland China pricing from BigModel pricing

3. Update the documentation reference at the top of the file to include the GLM-4.7 docs link

This follows the existing pattern used for GLM-4.5 and GLM-4.6 models already in the codebase.

Note

The issue mentions GLM-4.7 may add "thinking capabilities." If this requires special handling (like extended thinking/reasoning similar to other providers), please let me know and I can add that support as well.

Please mention @roomote in a comment saying that you approve this plan, and I'll proceed with the implementation.

[mdziekon]

The issue mentions GLM-4.7 may add "thinking capabilities." If this requires special handling (like extended thinking/reasoning similar to other providers), please let me know and I can add that support as well.

Please mention @roomote in a comment saying that you approve this plan, and I'll proceed with the implementation.

Let's focus on basic support now, the proposed plan sounds good for me.

Thanks for the approval! I've seen your comment and will proceed with the implementation to add basic GLM-4.7 support to the Z.ai provider. I'll open a PR to share progress.

Opened a draft PR with my attempt at adding basic GLM-4.7 support: #10271

The PR adds the glm-4.7 model entry to both international and mainland Z.ai model lists, following the existing pattern for GLM-4.5 and GLM-4.6.

Feedback welcome!

[kavehsfv]

@roomote
make sure it supports preserved thinking
https://docs.z.ai/guides/capabilities/thinking-mode

Preserved thinking
GLM-4.7 introduces a new capability in coding scenarios (the default status is on for coding endpoint, and off for other scenarios, and currently not configurable publicly): the model can retain reasoning content from previous assistant turns in the context. This helps preserve reasoning continuity and conversation integrity, improves model performance, and increases cache hit rates—saving tokens in real tasks.

Turn-level Thinking
“Turn-level Thinking” is a capability that lets you control reasoning computation on a per-turn basis: within the same session, each request can independently choose to enable or disable thinking. This is a new capability introduced in GLM-4.7, with the following advantages:
More flexible cost/latency control: For lightweight turns like “asking a fact” or “tweaking wording,” you can disable thinking to get faster responses; for heavier tasks like “complex planning,” “multi-constraint reasoning,” or “code debugging,” you can enable thinking to improve accuracy and stability.
Smoother multi-turn experience: The thinking switch can be toggled at any point within a session. The model stays coherent across turns and keeps a consistent output style, making it feel “smarter when things are hard, faster when things are simple.”
Better for agent/tool-use scenarios: On turns that require quick tool execution, you can reduce reasoning overhead; on turns that require making decisions based on tool results, you can turn on deeper thinking—dynamically balancing efficiency and quality.

Example Usage
This applies to both Interleaved Thinking and Preserved Thinking—no manual differentiation is required. Remember to return the historical reasoning_contentto keep the reasoning coherent.

""""Interleaved Thinking + Tool Calling Example"""

import json
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.z.ai/api/paas/v4/",
)

tools = [{"type": "function", "function": {
    "name": "get_weather",
    "description": "Get weather information",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
}}]

messages = [
    {"role": "system", "content": "You are an assistant"},
    {"role": "user", "content": "What's the weather like in Beijing?"},
]

# Round 1: the model reasons and then calls a tool
response = client.chat.completions.create(model="glm-4.6", messages=messages, tools=tools, stream=True)
reasoning, content, tool_calls = "", "", []
for chunk in response:
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
        reasoning += delta.reasoning_content
    if hasattr(delta, "content") and delta.content:
        content += delta.content
    if hasattr(delta, "tool_calls") and delta.tool_calls:
        for tc in delta.tool_calls:
            if tc.index >= len(tool_calls):
                tool_calls.append({"id": tc.id, "function": {"name": "", "arguments": ""}})
            if tc.function.name:
                tool_calls[tc.index]["function"]["name"] = tc.function.name
            if tc.function.arguments:
                tool_calls[tc.index]["function"]["arguments"] += tc.function.arguments

print(f"Reasoning: {reasoning}\nTool calls: {tool_calls}")

# Key: return reasoning_content to keep the reasoning coherent
messages.append({"role": "assistant", "content": content, "reasoning_content": reasoning,
                 "tool_calls": [{"id": tc["id"], "type": "function", "function": tc["function"]} for tc in tool_calls]})
messages.append({"role": "tool", "tool_call_id": tool_calls[0]["id"], 
                 "content": json.dumps({"weather": "Sunny", "temp": "25°C"})})

# Round 2: the model continues reasoning based on the tool result and responds
response = client.chat.completions.create(model="glm-4.6", messages=messages, tools=tools, stream=True)
reasoning, content = "", ""
for chunk in response:
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
        reasoning += delta.reasoning_content
    if hasattr(delta, "content") and delta.content:
        content += delta.content

print(f"Reasoning: {reasoning}\nReply: {content}")```

Thanks for the detailed information about preserved thinking! I've reviewed the Z.ai documentation you linked and will explore implementing support for the reasoning_content field to maintain reasoning coherence across turns.

This will likely involve:

1. Updating the GLM-4.7 model definition to indicate it supports reasoning
2. Ensuring the reasoning content is properly passed back in subsequent messages

I'll investigate the codebase to understand how reasoning is handled for other providers and open a PR with the implementation.

Opened a draft PR with my attempt at adding GLM-4.7 with preserved thinking support: #10278

The PR adds the glm-4.7 model entry to both international and mainland Z.ai model lists with preserveReasoning: true enabled, which allows reasoning content to be retained across turns for improved coherence and cache efficiency.

This follows the existing pattern used for DeepSeek reasoner models. The existing infrastructure already handles reasoning_content in streaming responses via the BaseOpenAiCompatibleProvider, so no additional handler changes were needed.

Feedback welcome!