glm-pro-cli 2026.8.11.0__tar.gz

glm_pro_cli-2026.8.11.0/.env.example

@@ -0,0 +1,3 @@
+ACEDATACLOUD_API_TOKEN=your_api_token_here
+ACEDATACLOUD_API_BASE_URL=https://api.acedata.cloud
+GLM_REQUEST_TIMEOUT=30

glm_pro_cli-2026.8.11.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## [0.1.0] - 2025-05-04
+
+### Added
+- Initial release of GLM CLI
+- `chat` command for GLM chat completions (`/glm/chat/completions`)
+- `models` command to list available GLM models
+- `config` command to show current configuration
+- Support for models: glm-5.1, glm-4.7, glm-4.6, glm-4.5-air, glm-3-turbo

glm_pro_cli-2026.8.11.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AceDataCloud
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

glm_pro_cli-2026.8.11.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.1
+Name: glm-pro-cli
+Version: 2026.8.11.0
+Summary: CLI tool for GLM Chat Completions via AceDataCloud
+Project-URL: Homepage, https://github.com/AceDataCloud/Clis
+Project-URL: Repository, https://github.com/AceDataCloud/Clis
+Project-URL: Issues, https://github.com/AceDataCloud/Clis/issues
+Project-URL: Changelog, https://github.com/AceDataCloud/Clis/blob/main/glm/CHANGELOG.md
+Author-email: AceDataCloud <support@acedata.cloud>
+Maintainer-email: AceDataCloud <support@acedata.cloud>
+License: MIT
+License-File: LICENSE
+Keywords: acedata,ai,chat,cli,command-line,glm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: all
+Requires-Dist: glm-pro-cli[dev,release,test]; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: release
+Requires-Dist: build>=1.2.0; extra == 'release'
+Requires-Dist: twine>=6.1.0; extra == 'release'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'test'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'test'
+Requires-Dist: pytest>=8.0.0; extra == 'test'
+Requires-Dist: respx>=0.21.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# GLM CLI
+
+A command-line tool for GLM chat completions via [AceDataCloud](https://platform.acedata.cloud).
+
+## Installation
+
+```bash
+pip install glm-pro-cli
+```
+
+## Quick Start
+
+```bash
+export ACEDATACLOUD_API_TOKEN=your_token
+
+glm chat "What is the capital of France?"
+glm chat "Explain AI" -m glm-5.2
+glm models
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `glm chat <prompt>` | Chat with a GLM model |
+| `glm models` | List available GLM models |
+| `glm config` | Show current configuration |
+
+## Global Options
+
+```
+--token TEXT    API token (or set ACEDATACLOUD_API_TOKEN env var)
+--version       Show version
+--help          Show help message
+```
+
+## Available Models
+
+| Model | Notes |
+|-------|-------|
+| `glm-5.2` | Latest GLM release |
+| `glm-5` | GLM-5 base model |
+| `glm-5-turbo` | GLM-5 Turbo |
+| `glm-5.1` | Earlier GLM-5 release |
+| `glm-4.7` | GLM-4 series (default) |
+| `glm-4.6` | GLM-4 series |
+| `glm-3-turbo` | GLM-3 Turbo |
+
+## Configuration
+
+Set environment variables or use a `.env` file:
+
+```bash
+ACEDATACLOUD_API_TOKEN=your_token
+ACEDATACLOUD_API_BASE_URL=https://api.acedata.cloud
+GLM_REQUEST_TIMEOUT=30
+```
+
+## License
+
+MIT

glm_pro_cli-2026.8.11.0/README.md

@@ -0,0 +1,61 @@
+# GLM CLI
+
+A command-line tool for GLM chat completions via [AceDataCloud](https://platform.acedata.cloud).
+
+## Installation
+
+```bash
+pip install glm-pro-cli
+```
+
+## Quick Start
+
+```bash
+export ACEDATACLOUD_API_TOKEN=your_token
+
+glm chat "What is the capital of France?"
+glm chat "Explain AI" -m glm-5.2
+glm models
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `glm chat <prompt>` | Chat with a GLM model |
+| `glm models` | List available GLM models |
+| `glm config` | Show current configuration |
+
+## Global Options
+
+```
+--token TEXT    API token (or set ACEDATACLOUD_API_TOKEN env var)
+--version       Show version
+--help          Show help message
+```
+
+## Available Models
+
+| Model | Notes |
+|-------|-------|
+| `glm-5.2` | Latest GLM release |
+| `glm-5` | GLM-5 base model |
+| `glm-5-turbo` | GLM-5 Turbo |
+| `glm-5.1` | Earlier GLM-5 release |
+| `glm-4.7` | GLM-4 series (default) |
+| `glm-4.6` | GLM-4 series |
+| `glm-3-turbo` | GLM-3 Turbo |
+
+## Configuration
+
+Set environment variables or use a `.env` file:
+
+```bash
+ACEDATACLOUD_API_TOKEN=your_token
+ACEDATACLOUD_API_BASE_URL=https://api.acedata.cloud
+GLM_REQUEST_TIMEOUT=30
+```
+
+## License
+
+MIT

glm_pro_cli-2026.8.11.0/glm_cli/__init__.py

@@ -0,0 +1,3 @@
+"""GLM CLI package."""
+
+__version__ = "0.1.0"

glm_pro_cli-2026.8.11.0/glm_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m glm_cli."""
+
+from glm_cli.main import cli
+
+if __name__ == "__main__":
+    cli()

glm_pro_cli-2026.8.11.0/glm_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""GLM CLI commands package."""

glm_pro_cli-2026.8.11.0/glm_cli/commands/_json.py

@@ -0,0 +1,46 @@
+"""Helpers for parsing JSON-valued CLI options."""
+
+import json
+from typing import Any
+
+import click
+
+
+def parse_json_value(value: str | None, option_name: str) -> Any:
+    """Parse a CLI option as JSON."""
+    if value is None:
+        return None
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError as exc:
+        raise click.BadParameter(f"{option_name} must be valid JSON.") from exc
+
+
+def parse_json_object(value: str | None, option_name: str) -> dict[str, Any] | None:
+    """Parse a CLI option as a JSON object."""
+    parsed = parse_json_value(value, option_name)
+    if parsed is None:
+        return None
+    if not isinstance(parsed, dict):
+        raise click.BadParameter(f"{option_name} must be a JSON object.")
+    return parsed
+
+
+def parse_json_array(value: str | None, option_name: str) -> list[Any] | None:
+    """Parse a CLI option as a JSON array."""
+    parsed = parse_json_value(value, option_name)
+    if parsed is None:
+        return None
+    if not isinstance(parsed, list):
+        raise click.BadParameter(f"{option_name} must be a JSON array.")
+    return parsed
+
+
+def parse_json_or_string(value: str | None, option_name: str) -> Any:
+    """Parse JSON when possible, otherwise keep plain strings."""
+    if value is None:
+        return None
+    stripped = value.strip()
+    if stripped.startswith("{") or stripped.startswith("["):
+        return parse_json_value(value, option_name)
+    return value

glm_pro_cli-2026.8.11.0/glm_cli/commands/chat.py

@@ -0,0 +1,270 @@
+"""Chat completion command."""
+
+import click
+
+from glm_cli.commands._json import (
+    parse_json_array,
+    parse_json_object,
+    parse_json_or_string,
+)
+from glm_cli.core.client import get_client
+from glm_cli.core.exceptions import GLMError
+from glm_cli.core.output import (
+    DEFAULT_MODEL,
+    GLM_MODELS,
+    print_chat_result,
+    print_error,
+    print_json,
+)
+
+
+@click.command()
+@click.argument("prompt")
+@click.option(
+    "-m",
+    "--model",
+    type=click.Choice(GLM_MODELS),
+    default=DEFAULT_MODEL,
+    show_default=True,
+    help="GLM model to use for chat completion.",
+)
+@click.option(
+    "-s",
+    "--system",
+    default=None,
+    help="System prompt to set the assistant's behavior.",
+)
+@click.option(
+    "--temperature",
+    default=None,
+    type=float,
+    help="Sampling temperature (0-2). Higher values = more random.",
+)
+@click.option(
+    "--max-tokens",
+    default=None,
+    type=int,
+    help="Maximum number of tokens to generate.",
+)
+@click.option(
+    "--max-completion-tokens",
+    default=None,
+    type=int,
+    help="Upper bound for tokens generated in a completion (including reasoning tokens).",
+)
+@click.option(
+    "-n",
+    "--count",
+    default=None,
+    type=int,
+    help="Number of completion choices to generate.",
+)
+@click.option(
+    "--top-p",
+    default=None,
+    type=float,
+    help="Nucleus sampling probability mass (0-1).",
+)
+@click.option(
+    "--frequency-penalty",
+    default=None,
+    type=float,
+    help="Penalize tokens by their frequency in the text so far (-2.0 to 2.0).",
+)
+@click.option(
+    "--presence-penalty",
+    default=None,
+    type=float,
+    help="Penalize tokens that have already appeared in the text (-2.0 to 2.0).",
+)
+@click.option(
+    "--seed",
+    default=None,
+    type=int,
+    help="Seed for deterministic sampling.",
+)
+@click.option(
+    "--stop",
+    default=None,
+    multiple=True,
+    help="Stop sequence(s) where the API will stop generating (repeatable, up to 4).",
+)
+@click.option(
+    "--user",
+    default=None,
+    help="Unique end-user identifier for monitoring and abuse detection.",
+)
+@click.option(
+    "--reasoning-effort",
+    type=click.Choice(["minimal", "low", "medium", "high"]),
+    default=None,
+    help="Reasoning effort for extended thinking models.",
+)
+@click.option(
+    "--service-tier",
+    type=click.Choice(["auto", "default", "flex", "scale", "priority"]),
+    default=None,
+    help="Processing type for serving the request.",
+)
+@click.option(
+    "--store",
+    is_flag=True,
+    default=False,
+    help="Store the output for model distillation or evals.",
+)
+@click.option(
+    "--logprobs",
+    is_flag=True,
+    default=False,
+    help="Return log probabilities of the output tokens.",
+)
+@click.option(
+    "--top-logprobs",
+    default=None,
+    type=click.IntRange(0, 20),
+    help="Number of most likely tokens (0-20) to return at each token position.",
+)
+@click.option(
+    "--parallel-tool-calls",
+    is_flag=True,
+    default=False,
+    help="Enable parallel function calling during tool use.",
+)
+@click.option(
+    "--stream", is_flag=True, default=False, help="Stream partial chat completion events."
+)
+@click.option(
+    "--response-format",
+    default=None,
+    help='Response format as JSON (e.g. \'{"type": "json_object"}\').',
+)
+@click.option(
+    "--tools",
+    default=None,
+    help='Tool definitions as a JSON array (e.g. \'[{"type":"function","function":{...}}]\').',
+)
+@click.option(
+    "--tool-choice",
+    default=None,
+    help='Tool selection mode or JSON object (e.g. "auto" or \'{"type":"function","function":{"name":"lookup"}}\').',
+)
+@click.option(
+    "--stream-options",
+    default=None,
+    help="Streaming options as a JSON object (e.g. '{\"include_usage\": true}').",
+)
+@click.option("--metadata", default=None, help="Metadata as a JSON object.")
+@click.option("--logit-bias", default=None, help="Logit bias map as a JSON object.")
+@click.option("--modalities", default=None, help="Requested modalities as a JSON array.")
+@click.option("--audio", default=None, help="Audio output settings as a JSON object.")
+@click.option("--prediction", default=None, help="Prediction settings as a JSON object.")
+@click.option("--web-search-options", default=None, help="Web search settings as a JSON object.")
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def chat(
+    ctx: click.Context,
+    prompt: str,
+    model: str,
+    system: str | None,
+    temperature: float | None,
+    max_tokens: int | None,
+    max_completion_tokens: int | None,
+    count: int | None,
+    top_p: float | None,
+    frequency_penalty: float | None,
+    presence_penalty: float | None,
+    seed: int | None,
+    stop: tuple[str, ...],
+    user: str | None,
+    reasoning_effort: str | None,
+    service_tier: str | None,
+    store: bool,
+    logprobs: bool,
+    top_logprobs: int | None,
+    parallel_tool_calls: bool,
+    stream: bool,
+    response_format: str | None,
+    tools: str | None,
+    tool_choice: str | None,
+    stream_options: str | None,
+    metadata: str | None,
+    logit_bias: str | None,
+    modalities: str | None,
+    audio: str | None,
+    prediction: str | None,
+    web_search_options: str | None,
+    output_json: bool,
+) -> None:
+    """Chat with a GLM model.
+
+    PROMPT is the user message to send to the model.
+
+    \b
+    Examples:
+      glm chat "What is the capital of France?"
+      glm chat "Explain quantum computing" -m glm-5.1
+      glm chat "Write a poem" --temperature 0.9
+      glm chat "Summarize this" -s "You are a concise summarizer"
+    """
+    client = get_client(ctx.obj.get("token"))
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+
+    try:
+        parsed_response_format = parse_json_object(response_format, "--response-format")
+        parsed_tools = parse_json_array(tools, "--tools")
+        parsed_tool_choice = parse_json_or_string(tool_choice, "--tool-choice")
+        parsed_stream_options = parse_json_object(stream_options, "--stream-options")
+        parsed_metadata = parse_json_object(metadata, "--metadata")
+        parsed_logit_bias = parse_json_object(logit_bias, "--logit-bias")
+        parsed_modalities = parse_json_array(modalities, "--modalities")
+        parsed_audio = parse_json_object(audio, "--audio")
+        parsed_prediction = parse_json_object(prediction, "--prediction")
+        parsed_web_search_options = parse_json_object(web_search_options, "--web-search-options")
+    except click.BadParameter as e:
+        print_error(e.format_message())
+        raise SystemExit(1) from None
+
+    payload: dict[str, object] = {
+        "model": model,
+        "messages": messages,
+        "stream": stream or None,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "max_completion_tokens": max_completion_tokens,
+        "n": count,
+        "response_format": parsed_response_format,
+        "tools": parsed_tools,
+        "tool_choice": parsed_tool_choice,
+        "top_p": top_p,
+        "frequency_penalty": frequency_penalty,
+        "presence_penalty": presence_penalty,
+        "seed": seed,
+        "stop": list(stop) if stop else None,
+        "stream_options": parsed_stream_options,
+        "user": user,
+        "reasoning_effort": reasoning_effort,
+        "service_tier": service_tier,
+        "store": store if store else None,
+        "metadata": parsed_metadata,
+        "logit_bias": parsed_logit_bias,
+        "logprobs": logprobs if logprobs else None,
+        "top_logprobs": top_logprobs,
+        "parallel_tool_calls": parallel_tool_calls if parallel_tool_calls else None,
+        "modalities": parsed_modalities,
+        "audio": parsed_audio,
+        "prediction": parsed_prediction,
+        "web_search_options": parsed_web_search_options,
+    }
+
+    try:
+        result = client.chat_completions(**payload)  # type: ignore[arg-type]
+        if output_json:
+            print_json(result)
+        else:
+            print_chat_result(result)
+    except GLMError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e

glm_pro_cli-2026.8.11.0/glm_cli/commands/info.py

@@ -0,0 +1,31 @@
+"""Info and utility commands."""
+
+import click
+
+from glm_cli.core.config import settings
+from glm_cli.core.output import console, print_models
+
+
+@click.command()
+def models() -> None:
+    """List available GLM models."""
+    print_models()
+
+
+@click.command()
+def config() -> None:
+    """Show current configuration."""
+    from rich.table import Table
+
+    table = Table(title="GLM CLI Configuration")
+    table.add_column("Setting", style="bold cyan")
+    table.add_column("Value")
+
+    table.add_row("API Base URL", settings.api_base_url)
+    table.add_row(
+        "API Token",
+        f"{settings.api_token[:8]}..." if settings.api_token else "[red]Not set[/red]",
+    )
+    table.add_row("Request Timeout", f"{settings.request_timeout}s")
+
+    console.print(table)

glm_pro_cli-2026.8.11.0/glm_cli/core/__init__.py

@@ -0,0 +1 @@
+"""GLM CLI core package."""

glm_pro_cli-2026.8.11.0/glm_cli/core/client.py

@@ -0,0 +1,95 @@
+"""HTTP client for GLM API."""
+
+from typing import Any
+
+import httpx
+
+from glm_cli.core.config import settings
+from glm_cli.core.exceptions import (
+    GLMAPIError,
+    GLMAuthError,
+    GLMTimeoutError,
+)
+
+
+class GLMClient:
+    """HTTP client for AceDataCloud GLM API."""
+
+    def __init__(self, api_token: str | None = None, base_url: str | None = None):
+        self.api_token = api_token if api_token is not None else settings.api_token
+        self.base_url = base_url or settings.api_base_url
+        self.timeout = settings.request_timeout
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get request headers with authentication."""
+        if not self.api_token:
+            raise GLMAuthError(
+                "API token not configured. Set ACEDATACLOUD_API_TOKEN or use --token option."
+            )
+        return {
+            "accept": "application/json",
+            "authorization": f"Bearer {self.api_token}",
+            "content-type": "application/json",
+        }
+
+    def request(
+        self,
+        endpoint: str,
+        payload: dict[str, Any],
+        timeout: float | None = None,
+    ) -> dict[str, Any]:
+        """Make a POST request to the GLM API."""
+        url = f"{self.base_url}{endpoint}"
+        request_timeout = timeout or self.timeout
+
+        # Remove None values from payload
+        payload = {k: v for k, v in payload.items() if v is not None}
+
+        with httpx.Client() as http_client:
+            try:
+                response = http_client.post(
+                    url,
+                    json=payload,
+                    headers=self._get_headers(),
+                    timeout=request_timeout,
+                )
+
+                if response.status_code == 401:
+                    raise GLMAuthError("Invalid API token")
+
+                if response.status_code == 403:
+                    raise GLMAuthError("Access denied. Check your API permissions.")
+
+                response.raise_for_status()
+                return response.json()  # type: ignore[no-any-return]
+
+            except httpx.TimeoutException as e:
+                raise GLMTimeoutError(
+                    f"Request to {endpoint} timed out after {request_timeout}s"
+                ) from e
+
+            except GLMAuthError:
+                raise
+
+            except httpx.HTTPStatusError as e:
+                raise GLMAPIError(
+                    message=e.response.text,
+                    code=f"http_{e.response.status_code}",
+                    status_code=e.response.status_code,
+                ) from e
+
+            except Exception as e:
+                if isinstance(e, GLMAPIError | GLMTimeoutError):
+                    raise
+                raise GLMAPIError(message=str(e)) from e
+
+    def chat_completions(self, **kwargs: Any) -> dict[str, Any]:
+        """Send a chat completion request."""
+        return self.request("/glm/chat/completions", kwargs)
+
+
+def get_client(token: str | None = None) -> GLMClient:
+    """Get a GLMClient instance, optionally overriding the token."""
+    if token:
+        return GLMClient(api_token=token)
+    return GLMClient()

glm_pro_cli-2026.8.11.0/glm_cli/core/config.py

@@ -0,0 +1,39 @@
+"""Configuration management for GLM CLI."""
+
+import os
+from dataclasses import dataclass, field
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@dataclass
+class Settings:
+    """Application settings loaded from environment variables."""
+
+    api_base_url: str = field(
+        default_factory=lambda: os.environ.get(
+            "ACEDATACLOUD_API_BASE_URL", "https://api.acedata.cloud"
+        )
+    )
+    api_token: str = field(default_factory=lambda: os.environ.get("ACEDATACLOUD_API_TOKEN", ""))
+    request_timeout: float = field(
+        default_factory=lambda: float(os.environ.get("GLM_REQUEST_TIMEOUT", "30"))
+    )
+
+    @property
+    def is_configured(self) -> bool:
+        """Check if the API token is configured."""
+        return bool(self.api_token)
+
+    def validate(self) -> None:
+        """Validate configuration. Raises ValueError if API token is missing."""
+        if not self.api_token:
+            raise ValueError(
+                "API token not configured. "
+                "Set ACEDATACLOUD_API_TOKEN environment variable or use --token option."
+            )
+
+
+settings = Settings()

glm_pro_cli-2026.8.11.0/glm_cli/core/exceptions.py

@@ -0,0 +1,37 @@
+"""Custom exceptions for GLM CLI."""
+
+
+class GLMError(Exception):
+    """Base exception for GLM CLI."""
+
+    def __init__(self, message: str, code: str = "unknown"):
+        self.message = message
+        self.code = code
+        super().__init__(message)
+
+
+class GLMAuthError(GLMError):
+    """Authentication error."""
+
+    def __init__(self, message: str = "Authentication failed"):
+        super().__init__(message, code="auth_error")
+
+
+class GLMAPIError(GLMError):
+    """API error with HTTP status code."""
+
+    def __init__(
+        self,
+        message: str = "API request failed",
+        code: str = "api_error",
+        status_code: int | None = None,
+    ):
+        self.status_code = status_code
+        super().__init__(message, code)
+
+
+class GLMTimeoutError(GLMError):
+    """Request timeout error."""
+
+    def __init__(self, message: str = "Request timed out"):
+        super().__init__(message, code="timeout_error")

glm_pro_cli-2026.8.11.0/glm_cli/core/output.py

@@ -0,0 +1,100 @@
+"""Rich terminal output formatting for GLM CLI."""
+
+import json
+from typing import Any
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+# Available GLM chat models
+GLM_MODELS = [
+    "glm-5.2",
+    "glm-5",
+    "glm-5-turbo",
+    "glm-5.1",
+    "glm-4.7",
+    "glm-4.6",
+    "glm-3-turbo",
+]
+
+DEFAULT_MODEL = "glm-4.7"
+
+
+def print_json(data: Any) -> None:
+    """Print data as formatted JSON."""
+    click.echo(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def print_error(message: str) -> None:
+    """Print an error message."""
+    console.print(f"[bold red]Error:[/bold red] {message}")
+
+
+def print_success(message: str) -> None:
+    """Print a success message."""
+    console.print(f"[bold green]\u2713[/bold green] {message}")
+
+
+def print_chat_result(data: dict[str, Any]) -> None:
+    """Print a chat completion result."""
+    choices = data.get("choices", [])
+    if choices:
+        for i, choice in enumerate(choices, 1):
+            message = choice.get("message", {})
+            content = message.get("content", "")
+            role = message.get("role", "assistant")
+            finish_reason = choice.get("finish_reason", "")
+            title = (
+                f"[bold green]Response #{i}[/bold green]"
+                if len(choices) > 1
+                else "[bold green]Response[/bold green]"
+            )
+            console.print(
+                Panel(
+                    content or "[dim](empty)[/dim]",
+                    title=title,
+                    subtitle=(
+                        f"[dim]{role} \u00b7 {finish_reason}[/dim]"
+                        if finish_reason
+                        else f"[dim]{role}[/dim]"
+                    ),
+                    border_style="green",
+                )
+            )
+    else:
+        console.print("[yellow]No response content available.[/yellow]")
+
+    usage = data.get("usage", {})
+    if usage:
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("Field", style="dim")
+        table.add_column("Value", style="dim")
+        if usage.get("prompt_tokens"):
+            table.add_row("Prompt tokens", str(usage["prompt_tokens"]))
+        if usage.get("completion_tokens"):
+            table.add_row("Completion tokens", str(usage["completion_tokens"]))
+        if usage.get("total_tokens"):
+            table.add_row("Total tokens", str(usage["total_tokens"]))
+        console.print(table)
+
+
+def print_models() -> None:
+    """Print available GLM models."""
+    table = Table(title="Available GLM Models")
+    table.add_column("Model", style="bold cyan")
+    table.add_column("Notes")
+
+    table.add_row("glm-5.2", "Latest GLM release")
+    table.add_row("glm-5", "GLM-5 base model")
+    table.add_row("glm-5-turbo", "GLM-5 Turbo")
+    table.add_row("glm-5.1", "Earlier GLM-5 release")
+    table.add_row("glm-4.7", "GLM-4 series (default)")
+    table.add_row("glm-4.6", "GLM-4 series")
+    table.add_row("glm-3-turbo", "GLM-3 Turbo")
+
+    console.print(table)
+    console.print(f"\n[dim]Default model: {DEFAULT_MODEL}[/dim]")

glm_pro_cli-2026.8.11.0/glm_cli/main.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+GLM CLI - GLM Chat Completions via AceDataCloud.
+
+A command-line tool for GLM chat completions powered by AceDataCloud.
+"""
+
+from importlib import metadata
+
+import click
+from dotenv import load_dotenv
+
+from glm_cli.commands.chat import chat
+from glm_cli.commands.info import config, models
+
+load_dotenv()
+
+
+def get_version() -> str:
+    """Get the package version."""
+    try:
+        return metadata.version("glm-pro-cli")
+    except metadata.PackageNotFoundError:
+        return "dev"
+
+
+@click.group()
+@click.version_option(version=get_version(), prog_name="glm-cli")
+@click.option(
+    "--token",
+    envvar="ACEDATACLOUD_API_TOKEN",
+    help="API token (or set ACEDATACLOUD_API_TOKEN env var).",
+)
+@click.pass_context
+def cli(ctx: click.Context, token: str | None) -> None:
+    """GLM CLI - GLM Chat Completions via AceDataCloud.
+
+    Chat with GLM models from the command line.
+
+    Get your API token at https://platform.acedata.cloud
+
+    \b
+    Examples:
+      glm chat "What is the capital of France?"
+      glm chat "Explain AI" -m glm-5.1
+      glm models
+
+    Set your token:
+      export ACEDATACLOUD_API_TOKEN=your_token
+    """
+    ctx.ensure_object(dict)
+    ctx.obj["token"] = token
+
+
+# Register commands
+cli.add_command(chat)
+cli.add_command(models)
+cli.add_command(config)
+
+
+if __name__ == "__main__":
+    cli()

glm_pro_cli-2026.8.11.0/pyproject.toml

@@ -0,0 +1,116 @@
+[project]
+name = "glm-pro-cli"
+version = "2026.8.11.0"
+description = "CLI tool for GLM Chat Completions via AceDataCloud"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [
+    { name = "AceDataCloud", email = "support@acedata.cloud" }
+]
+maintainers = [
+    { name = "AceDataCloud", email = "support@acedata.cloud" }
+]
+keywords = [
+    "cli",
+    "glm",
+    "chat",
+    "ai",
+    "acedata",
+    "command-line",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Environment :: Console",
+]
+dependencies = [
+    "click>=8.1.0",
+    "httpx>=0.27.0",
+    "python-dotenv>=1.0.0",
+    "rich>=13.0.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ruff>=0.4.0",
+    "mypy>=1.10.0",
+    "pre-commit>=3.7.0",
+]
+test = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=5.0.0",
+    "respx>=0.21.0",
+]
+release = [
+    "build>=1.2.0",
+    "twine>=6.1.0",
+]
+all = [
+    "glm-pro-cli[dev,test,release]",
+]
+
+[project.scripts]
+glm-cli = "glm_cli.main:cli"
+glm = "glm_cli.main:cli"
+
+[project.urls]
+Homepage = "https://github.com/AceDataCloud/Clis"
+Repository = "https://github.com/AceDataCloud/Clis"
+Issues = "https://github.com/AceDataCloud/Clis/issues"
+Changelog = "https://github.com/AceDataCloud/Clis/blob/main/glm/CHANGELOG.md"
+
+[build-system]
+requires = ["hatchling>=1.21.0,<1.22.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["glm_cli"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "glm_cli/",
+    "tests/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    ".env.example",
+]
+
+# Mypy Configuration
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+check_untyped_defs = true
+
+# Pytest Configuration
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+markers = [
+    "integration: marks tests that require real API access",
+    "slow: marks slow tests",
+]
+
+# Ruff Configuration
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "B", "C4", "UP", "ARG", "SIM"]
+ignore = ["E501"]
+
+[tool.ruff.format]
+quote-style = "double"

glm_pro_cli-2026.8.11.0/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests init."""

glm_pro_cli-2026.8.11.0/tests/conftest.py

@@ -0,0 +1,28 @@
+"""Test configuration and fixtures for GLM CLI."""
+
+import pytest
+
+
+@pytest.fixture
+def mock_chat_response() -> dict:
+    return {
+        "id": "chatcmpl-test-123",
+        "object": "chat.completion",
+        "created": 1700000000,
+        "model": "glm-4.7",
+        "choices": [
+            {
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": "The capital of France is Paris.",
+                },
+                "finish_reason": "stop",
+            }
+        ],
+        "usage": {
+            "prompt_tokens": 10,
+            "completion_tokens": 20,
+            "total_tokens": 30,
+        },
+    }

glm_pro_cli-2026.8.11.0/tests/test_commands.py

@@ -0,0 +1,225 @@
+"""Tests for GLM CLI commands."""
+
+import json
+
+import pytest
+import respx
+from click.testing import CliRunner
+from httpx import Response
+
+from glm_cli.main import cli, get_version
+
+
+@pytest.fixture
+def runner() -> CliRunner:
+    return CliRunner()
+
+
+class TestGlobalCommands:
+    """Tests for global CLI options."""
+
+    def test_version(self, runner):
+        result = runner.invoke(cli, ["--version"])
+        assert result.exit_code == 0
+        assert "glm-cli" in result.output
+
+    def test_version_uses_distribution_name(self, monkeypatch):
+        monkeypatch.setattr(
+            "glm_cli.main.metadata.version",
+            lambda name: "1.2.3" if name == "glm-pro-cli" else None,
+        )
+
+        assert get_version() == "1.2.3"
+
+    def test_help(self, runner):
+        result = runner.invoke(cli, ["--help"])
+        assert result.exit_code == 0
+        assert "chat" in result.output
+
+    def test_help_chat(self, runner):
+        result = runner.invoke(cli, ["chat", "--help"])
+        assert result.exit_code == 0
+        assert "PROMPT" in result.output
+        assert "--model" in result.output
+
+
+class TestChatCommand:
+    """Tests for chat commands."""
+
+    @respx.mock
+    def test_chat_json(self, runner, mock_chat_response):
+        respx.post("https://api.acedata.cloud/glm/chat/completions").mock(
+            return_value=Response(200, json=mock_chat_response)
+        )
+        result = runner.invoke(
+            cli, ["--token", "test-token", "chat", "What is the capital of France?", "--json"]
+        )
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["choices"][0]["message"]["content"] == "The capital of France is Paris."
+
+    @respx.mock
+    def test_chat_rich_output(self, runner, mock_chat_response):
+        respx.post("https://api.acedata.cloud/glm/chat/completions").mock(
+            return_value=Response(200, json=mock_chat_response)
+        )
+        result = runner.invoke(cli, ["--token", "test-token", "chat", "Hello"])
+        assert result.exit_code == 0
+        assert "Paris" in result.output
+
+    @respx.mock
+    def test_chat_with_model(self, runner, mock_chat_response):
+        route = respx.post("https://api.acedata.cloud/glm/chat/completions").mock(
+            return_value=Response(200, json=mock_chat_response)
+        )
+        result = runner.invoke(
+            cli, ["--token", "test-token", "chat", "Hello", "-m", "glm-5-turbo", "--json"]
+        )
+        assert result.exit_code == 0
+        body = json.loads(route.calls.last.request.content)
+        assert body["model"] == "glm-5-turbo"
+
+    @respx.mock
+    def test_chat_with_system_prompt(self, runner, mock_chat_response):
+        respx.post("https://api.acedata.cloud/glm/chat/completions").mock(
+            return_value=Response(200, json=mock_chat_response)
+        )
+        result = runner.invoke(
+            cli,
+            [
+                "--token",
+                "test-token",
+                "chat",
+                "Hello",
+                "-s",
+                "You are a helpful assistant",
+                "--json",
+            ],
+        )
+        assert result.exit_code == 0
+
+    @respx.mock
+    def test_chat_with_temperature(self, runner, mock_chat_response):
+        respx.post("https://api.acedata.cloud/glm/chat/completions").mock(
+            return_value=Response(200, json=mock_chat_response)
+        )
+        result = runner.invoke(
+            cli, ["--token", "test-token", "chat", "Hello", "--temperature", "0.5", "--json"]
+        )
+        assert result.exit_code == 0
+
+    @respx.mock
+    def test_chat_with_openai_compatible_options(self, runner, mock_chat_response):
+        route = respx.post("https://api.acedata.cloud/glm/chat/completions").mock(
+            return_value=Response(200, json=mock_chat_response)
+        )
+        result = runner.invoke(
+            cli,
+            [
+                "--token",
+                "test-token",
+                "chat",
+                "Hello",
+                "--max-completion-tokens",
+                "512",
+                "--reasoning-effort",
+                "high",
+                "--service-tier",
+                "priority",
+                "--store",
+                "--logprobs",
+                "--top-logprobs",
+                "3",
+                "--parallel-tool-calls",
+                "--json",
+            ],
+        )
+        assert result.exit_code == 0
+        body = json.loads(route.calls.last.request.content)
+        assert body["max_completion_tokens"] == 512
+        assert body["reasoning_effort"] == "high"
+        assert body["service_tier"] == "priority"
+        assert body["store"] is True
+        assert body["logprobs"] is True
+        assert body["top_logprobs"] == 3
+        assert body["parallel_tool_calls"] is True
+
+    @respx.mock
+    def test_chat_with_extended_openapi_options(self, runner, mock_chat_response):
+        route = respx.post("https://api.acedata.cloud/glm/chat/completions").mock(
+            return_value=Response(200, json=mock_chat_response)
+        )
+        result = runner.invoke(
+            cli,
+            [
+                "--token",
+                "test-token",
+                "chat",
+                "Hello",
+                "--stream",
+                "--response-format",
+                '{"type": "json_object"}',
+                "--tools",
+                '[{"type":"function","function":{"name":"lookup"}}]',
+                "--tool-choice",
+                "auto",
+                "--stream-options",
+                '{"include_usage": true}',
+                "--metadata",
+                '{"source": "test"}',
+                "--logit-bias",
+                '{"123": -1}',
+                "--modalities",
+                '["text"]',
+                "--audio",
+                '{"voice": "alloy"}',
+                "--prediction",
+                '{"type": "content", "content": "Hello"}',
+                "--web-search-options",
+                '{"search_context_size": "low"}',
+                "--json",
+            ],
+        )
+        assert result.exit_code == 0
+        body = json.loads(route.calls.last.request.content)
+        assert body["stream"] is True
+        assert body["response_format"] == {"type": "json_object"}
+        assert body["tools"] == [{"type": "function", "function": {"name": "lookup"}}]
+        assert body["tool_choice"] == "auto"
+        assert body["stream_options"] == {"include_usage": True}
+        assert body["metadata"] == {"source": "test"}
+        assert body["logit_bias"] == {"123": -1}
+        assert body["modalities"] == ["text"]
+        assert body["audio"] == {"voice": "alloy"}
+        assert body["prediction"] == {"type": "content", "content": "Hello"}
+        assert body["web_search_options"] == {"search_context_size": "low"}
+
+    def test_chat_rejects_invalid_json_option(self, runner):
+        result = runner.invoke(
+            cli,
+            ["--token", "test-token", "chat", "Hello", "--metadata", "not-json"],
+        )
+        assert result.exit_code != 0
+        assert "--metadata must be valid JSON." in result.output
+
+    def test_chat_no_token(self, runner):
+        result = runner.invoke(cli, ["--token", "", "chat", "Hello"])
+        assert result.exit_code != 0
+
+
+class TestInfoCommands:
+    """Tests for info and utility commands."""
+
+    def test_models(self, runner):
+        result = runner.invoke(cli, ["models"])
+        assert result.exit_code == 0
+        assert "glm-5.2" in result.output
+        assert "glm-5" in result.output
+        assert "glm-5-turbo" in result.output
+        assert "glm-4.7" in result.output
+        assert "glm-5.1" in result.output
+
+    def test_config(self, runner):
+        result = runner.invoke(cli, ["config"])
+        assert result.exit_code == 0
+        assert "api.acedata.cloud" in result.output