glm-acp-agent 1.1.3 → 1.2.0

package/README.md

@@ -1,6 +1,6 @@
 # glm-acp-agent
 
-An [Agent Client Protocol (ACP)](https://agentclientprotocol.com) agent written in TypeScript that uses the **Z.AI / Zhipu AI GLM** model family (GLM-5.1, GLM-4.7, GLM-4.6, …) as its reasoning core.
+An [Agent Client Protocol (ACP)](https://agentclientprotocol.com) agent written in TypeScript that uses the **Z.AI / Zhipu AI GLM** model family (GLM-5.2, GLM-5.1, GLM-4.7, …) as its reasoning core.
 
 The agent connects to any ACP-compatible IDE or client over **stdio**, streams responses back in real time, and can call a rich set of tools to interact with the user's file system, terminal, and the web.
 
@@ -28,12 +28,13 @@ Built-in web tools use Coding Plan-compatible MCP endpoints, not the general `/a
 - **Streaming** – assistant text and reasoning tokens are forwarded as incremental ACP chunks
 - **Tool calling** – agentic loop with up to 20 turns of GLM function calling
 - **Thinking mode** – GLM's `reasoning_content` tokens are surfaced as `agent_thought_chunk` blocks so the client can show the model's chain of thought
+- **Session permission modes** – supports `default`, `accept_edits`, and `bypass_permissions` via `session/set_mode`. Clients like DevFlow can use this to toggle between prompting for every edit, auto-approving edits while prompting for commands, or bypassing permissions entirely.
 - **Per-session model switching** – `session/set_model` lets clients change the active GLM model mid-conversation; `session/new` returns the curated `availableModels` list
-- **Image input via Coding Plan Vision MCP** – `promptCapabilities.image` is advertised; pasted ACP image blocks are routed through Z.AI Vision MCP (`@z_ai/mcp-server`) and the resulting analysis is fed into the main coding model. Direct chat-image (e.g. `glm-4v-plus`) calls are intentionally not used.
+- **Image input via Coding Plan-native vision or Vision MCP** – `promptCapabilities.image` is advertised; `glm-5v-turbo` sessions send supported image parts directly to the model, while non-native coding models route pasted ACP image blocks through Z.AI Vision MCP (`@z_ai/mcp-server`). Direct chat-image-only models (e.g. `glm-4v-plus`) are intentionally not used.
 - **Session persistence** – conversations are written to `~/.local/state/glm-acp-agent/sessions/` and can be reloaded via `session/load`, branched via `session/fork`, or resumed without replay via `session/resume`
 - **Six built-in tools** (see below)
 - **Self-sufficient local tools** – file reads/writes, directory listings, and shell commands run in the agent process, so they do not depend on ACP client `fs` or `terminal` capabilities
-- **Permissioned writes / commands** – every `write_file` and `run_command` call asks the user via `session/request_permission` before doing anything
+- **Configurable permissions** – `write_file` and `run_command` behavior depends on the active session mode (prompts by default)
 - **Protocol-correct stop reasons** – maps model and runtime conditions to ACP `end_turn`, `max_tokens`, `max_turn_requests`, `refusal`, and `cancelled`
 - **Protocol-correct tool statuses** – `pending` → `in_progress` → `completed` / `failed`
 - **Token usage reporting** – aggregated usage is returned on the `session/prompt` response
@@ -65,15 +66,27 @@ The agent process needs network access to `api.z.ai` for chat completions and We
 
 ## Available Tools
 
-| Tool | Runs on | Requires client capability | Description |
-|------|---------|----------------------------|-------------|
-| `read_file` | Agent process | – | Read the text content of a file |
-| `write_file` | Agent process | ACP permission prompt | Write or overwrite a text file (asks for permission) |
-| `list_files` | Agent process | – | List a directory using Node filesystem APIs |
-| `run_command` | Agent process | ACP permission prompt | Run an arbitrary shell command via `sh -c` in the session cwd (asks for permission) |
-| `web_search` | Agent (Z.AI Coding Plan MCP) | – | Search the web — returns titles, URLs, and summaries |
-| `web_reader` | Agent (Z.AI Coding Plan MCP) | – | Fetch and parse a web page (markdown or plain text) |
-| `image_analysis` | Agent (Z.AI Vision MCP, stdio) | – | Analyze a local image path or remote URL using `@z_ai/mcp-server` |
+| Tool | Runs on | Permission behavior | Description |
+|------|---------|---------------------|-------------|
+| `read_file` | Agent process | Always silent | Read the text content of a file |
+| `write_file` | Agent process | Mode-dependent | Write or overwrite a text file. Silent in `accept_edits` and `bypass_permissions`. |
+| `list_files` | Agent process | Always silent | List a directory using Node filesystem APIs |
+| `run_command` | Agent process | Mode-dependent | Run an arbitrary shell command. Silent only in `bypass_permissions`. |
+| `web_search` | Agent (Z.AI Coding Plan MCP) | Always silent | Search the web — returns titles, URLs, and summaries |
+| `web_reader` | Agent (Z.AI Coding Plan MCP) | Always silent | Fetch and parse a web page (markdown or plain text) |
+| `image_analysis` | Agent (Z.AI Vision MCP, stdio) | Always silent | Analyze a local image path or remote URL using `@z_ai/mcp-server` |
+
+### Session Modes
+
+Clients can use `session/set_mode` to drive the permission policy:
+
+| Mode ID | Name | `write_file` | `run_command` |
+|---|---|---|---|
+| `default` | Ask for permission | **Prompt** | **Prompt** |
+| `accept_edits` | Auto-approve edits | Silent | **Prompt** |
+| `bypass_permissions` | Bypass all permissions | Silent | Silent |
+
+Reads, listings, and MCP tool calls are always silent across all modes.
 
 ---
 
@@ -87,6 +100,27 @@ The agent process needs network access to `api.z.ai` for chat completions and We
 
 ## Installation
 
+### Quick Start
+
+Install the published package globally to get the `glm-acp-agent` command on your `PATH`:
+
+```bash
+npm install -g glm-acp-agent@latest
+```
+
+Then either export your Z.AI API key and run it directly:
+
+```bash
+export Z_AI_API_KEY=your_key_here
+glm-acp-agent
+```
+
+…or run the interactive setup once to persist the key to disk (see [One-time setup](#one-time-setup)) and point any ACP-compatible client at the `glm-acp-agent` command.
+
+### From Source (Development)
+
+Clone the repository if you want to hack on the agent or pin a specific commit:
+
 ```bash
 git clone https://github.com/stefandevo/glm-acp-agent.git
 cd glm-acp-agent
@@ -94,6 +128,8 @@ npm install
 npm run build
 ```
 
+The build output lands in `dist/`; the rest of this README uses `node dist/index.js` whenever it refers to the source-build entry point.
+
 ---
 
 ## Configuration
@@ -103,7 +139,7 @@ The agent reads its configuration from environment variables, plus an optional c
 | Variable | Required | Default | Description |
 |----------|----------|---------|-------------|
 | `Z_AI_API_KEY` | One of env / `--setup` | — | API key for the Z.AI / Zhipu AI service. If unset, the credentials file is consulted. |
-| `ACP_GLM_MODEL` | No | `glm-5.1` | Default GLM model for new sessions |
+| `ACP_GLM_MODEL` | No | `glm-5.2` | Default GLM model for new sessions |
 | `ACP_GLM_AVAILABLE_MODELS` | No | built-in list | Comma-separated list of model ids advertised in `session/set_model` |
 | `ACP_GLM_BASE_URL` | No | `https://api.z.ai/api/coding/paas/v4` | Override the API base URL |
 | `ACP_GLM_MAX_TOKENS` | No | `8192` | Cap on `max_tokens` for each completion |
@@ -117,13 +153,15 @@ The agent reads its configuration from environment variables, plus an optional c
 If you'd rather not pass `Z_AI_API_KEY` through your ACP client's environment block, run the interactive setup once and the agent will read the key from disk on subsequent launches:
 
 ```bash
-# From the project directory (after npm run build)
-node dist/index.js --setup
-
-# Or, if you installed globally
 glm-acp-agent --setup
 ```
 
+If you're working from a source clone instead of the published package, use the build output directly:
+
+```bash
+node dist/index.js --setup
+```
+
 The key is written to `$XDG_CONFIG_HOME/glm-acp-agent/credentials.json` (default: `~/.config/glm-acp-agent/credentials.json`) with `0600` permissions. The `Z_AI_API_KEY` environment variable, when set, always wins over the file.
 
 ### Supported models
@@ -132,20 +170,37 @@ The agent advertises only the models on the current Z.AI Coding Plan allowlist:
 
 | Model | Notes |
 |-------|-------|
-| `glm-5.1` | **Default.** Long-horizon coding model; thinking mode auto-enabled |
+| `glm-5.2` | **Default.** Newest 1M-context coding model; thinking mode auto-enabled |
+| `glm-5.1` | Long-horizon coding model; thinking mode auto-enabled |
 | `glm-5-turbo` | Faster Coding Plan reasoning model |
+| `glm-5v-turbo` | Multimodal Coding Plan model; native image understanding for jpg / jpeg / png inputs |
 | `glm-4.7` | 200K-context reasoning model |
 | `glm-4.5-air` | Lightweight, lower-latency model |
 
-`ACP_GLM_AVAILABLE_MODELS` still lets you advertise custom IDs, but custom IDs sit outside the supported Coding Plan list — the Coding Plan endpoint will reject any model code Z.AI hasn't whitelisted (business code `1211`).
+`ACP_GLM_AVAILABLE_MODELS` still lets you advertise custom IDs, but custom IDs sit outside the supported Coding Plan list — the Coding Plan endpoint will reject any model code Z.AI hasn't whitelisted (business code `1211`). If you override the model list, include `glm-5v-turbo` yourself to keep it visible in the picker.
+
+Vision-only chat models (`glm-4v-plus` etc.) are **not** advertised. The multimodal coding model `glm-5v-turbo` is advertised because it is on the Coding Plan and receives supported ACP image blocks directly as native `image_url` content parts. Other advertised models keep using the [Vision MCP](#vision-mcp) path for image analysis.
 
-Vision (`glm-4v-plus` etc.) is **not** advertised as a chat model: vision on the Coding Plan flows through the [Vision MCP](#vision-mcp) section below instead.
+When the model name matches `glm-4.5`, `glm-4.6`, `glm-4.7`, or the `glm-5` family, the agent enables Z.AI's `thinking: { type: "enabled" }` extension and forwards reasoning tokens to the client as `agent_thought_chunk` blocks. This includes `glm-5v-turbo`. Override with `ACP_GLM_THINKING=false` if you want plain completions only.
 
-When the model name matches `glm-4.5`, `glm-4.6`, `glm-4.7`, or `glm-5.x`, the agent enables Z.AI's `thinking: { type: "enabled" }` extension and forwards reasoning tokens to the client as `agent_thought_chunk` blocks. Override with `ACP_GLM_THINKING=false` if you want plain completions only.
+#### Thought level (reasoning effort)
+
+The agent advertises a `thought_level` [SessionConfigOption](https://agentclientprotocol.com) so clients that support config options (e.g. a "Thinking" selector) can control reasoning effort per session. The available levels depend on the active model:
+
+| Model | Levels | Mapping to the Z.AI request |
+|-------|--------|-----------------------------|
+| `glm-5.2` | `Off` / `High` / `Max` | `Off` → `thinking: { type: "disabled" }`; `High`/`Max` → `thinking: { type: "enabled" }` + `reasoning_effort: "high"` / `"max"` |
+| other thinking-capable models | `Off` / `On` | `Off` → `thinking: { type: "disabled" }`; `On` → `thinking: { type: "enabled" }` |
+
+`reasoning_effort` is a GLM-5.2 extra — other models never receive it. New sessions default to the model's own default effort (`Max` on GLM-5.2, which is also Z.AI's default when the field is omitted), so out-of-the-box behaviour is unchanged. Switching models re-clamps the level (e.g. a `High` selection reverts to `On` when you move off GLM-5.2) and pushes a `config_option_update`. The `ACP_GLM_THINKING` env override still wins: `false` forces thinking off regardless of the selected level. Clients that don't support config options simply ignore the advertised option and get the default behaviour.
+
+`ACP_GLM_PROMPT_IMAGES=false` still hides the image-attachment capability at session startup. With that flag set, users can pick `glm-5v-turbo` for text work but clients should not offer image attachments.
 
 ### Vision MCP
 
-Pasted ACP image blocks are not sent to the chat-completions endpoint. Instead, the agent boots `@z_ai/mcp-server` over stdio (via `npx -y @z_ai/mcp-server@latest`) and calls its `image_analysis` tool. The text result is spliced into the user message as `<image_analysis index="N">…</image_analysis>` so the regular Coding Plan model can reason about it.
+For `glm-5v-turbo`, pasted ACP image blocks with `image/jpeg`, `image/jpg`, or `image/png` are sent directly to chat completions as `image_url` content parts. HTTPS image URLs are forwarded as URLs; inline base64 data is sent as a `data:<mime>;base64,...` URI. Unsupported image MIME types are rejected client-side with an inline `<image_unsupported_format>` annotation so the prompt can continue without a provider 4xx.
+
+For non-native models, pasted ACP image blocks are not sent to the chat-completions endpoint. Instead, the agent boots `@z_ai/mcp-server` over stdio (via `npx -y @z_ai/mcp-server@latest`) and calls its `image_analysis` tool. The text result is spliced into the user message as `<image_analysis index="N">…</image_analysis>` so the regular Coding Plan model can reason about it.
 
 Prerequisites:
 
@@ -160,23 +215,26 @@ The model can also call `image_analysis` explicitly with `{ image_source: "/path
 
 ### Standalone (stdio)
 
+If you installed the published package globally, just run the CLI:
+
 ```bash
 export Z_AI_API_KEY=your_key_here
-node dist/index.js
+glm-acp-agent
 ```
 
-The agent speaks the ACP newline-delimited JSON protocol over stdin/stdout. You can connect any ACP-compatible client to it.
-
-### As a global CLI
+If you built from source, invoke the entry point directly:
 
 ```bash
-npm install -g .
 export Z_AI_API_KEY=your_key_here
-glm-acp-agent
+node dist/index.js
 ```
 
+The agent speaks the ACP newline-delimited JSON protocol over stdin/stdout. You can connect any ACP-compatible client to it.
+
 ### Development mode (watch)
 
+When working from a source clone, run `tsc` in watch mode so `dist/` rebuilds on every save:
+
 ```bash
 export Z_AI_API_KEY=your_key_here
 npm run dev        # tsc --watch
@@ -196,20 +254,16 @@ npm run dev        # tsc --watch
 - Node.js 20 or later on your `PATH` (`node --version`)
 - A Z.AI API key — create one at <https://z.ai/manage-apikey/apikey-list>
 
-#### 2. Build the agent
+#### 2. Install the agent
 
-```bash
-git clone https://github.com/stefandevo/glm-acp-agent.git
-cd glm-acp-agent
-npm install
-npm run build
-```
+Follow either path from the [Installation](#installation) section above:
 
-Take note of the absolute path to the freshly built entry point — Zed needs it (no `~`, no `$HOME` shortcuts):
+- **Quick Start** — `npm install -g glm-acp-agent@latest`. Zed can then spawn the agent with `"command": "glm-acp-agent"`.
+- **From source** — clone, `npm install`, `npm run build`. Zed needs the absolute path to the built entry point (no `~`, no `$HOME` shortcuts):
 
-```bash
-echo "$(pwd)/dist/index.js"
-```
+  ```bash
+  echo "$(pwd)/dist/index.js"
+  ```
 
 #### 3. Wire it into Zed
 
@@ -217,6 +271,19 @@ Open (or create) `~/.config/zed/settings.json` and add an `agent_servers` entry.
 
 **Option A — inline `env` block (simplest):**
 
+```json
+{
+  "agent_servers": {
+    "glm": {
+      "command": "glm-acp-agent",
+      "env": { "Z_AI_API_KEY": "sk-…" }
+    }
+  }
+}
+```
+
+If you installed from source instead of the published package, replace `command` / `args` with the absolute path to the build output:
+
 ```json
 {
   "agent_servers": {
@@ -231,26 +298,21 @@ Open (or create) `~/.config/zed/settings.json` and add an `agent_servers` entry.
 
 **Option B — credentials file (no key in your editor settings):**
 
-Run the interactive setup once. From the project directory:
-
-```bash
-node dist/index.js --setup
-```
-
-…or, if you `npm install -g .`'d the package:
+Run the interactive setup once:
 
 ```bash
 glm-acp-agent --setup
 ```
 
+If you're working from a source clone, use the build output directly: `node dist/index.js --setup`.
+
 The key is written to `~/.config/glm-acp-agent/credentials.json` with `0600` permissions. Then drop the `env` block from the Zed entry — the agent will read the file on launch:
 
 ```json
 {
   "agent_servers": {
     "glm": {
-      "command": "node",
-      "args": ["/absolute/path/to/glm-acp-agent/dist/index.js"]
+      "command": "glm-acp-agent"
     }
   }
 }
@@ -264,7 +326,7 @@ If `Z_AI_API_KEY` is set in the environment **and** a credentials file exists, t
 2. Open the **agent panel** (use the command palette: `agent panel: toggle focus`).
 3. In the agent picker, select **glm** — Zed labels external agents by their `agent_servers` key.
 4. Start a new thread and send a small prompt that exercises a tool, e.g. `Read package.json and tell me the project name.`
-5. You should see streaming text, a `read_file` tool call awaiting permission, and (with a thinking-capable model like `glm-5.1`) reasoning surfaced as a separate thought block.
+5. You should see streaming text, a `read_file` tool call awaiting permission, and (with a thinking-capable model like `glm-5.2`) reasoning surfaced as a separate thought block.
 
 #### 5. Iterating on the agent
 
@@ -288,7 +350,12 @@ For a tighter inner loop, run `npm run dev` in a terminal so `dist/` rebuilds on
 
 ### Neovim / VS Code / JetBrains / any ACP client
 
-Any client that supports configuring an ACP agent via a `command` + `args` invocation works the same way: point it at `node /absolute/path/to/glm-acp-agent/dist/index.js` and supply `Z_AI_API_KEY` in the environment.
+Any client that supports configuring an ACP agent via a `command` + `args` invocation works the same way:
+
+- If you installed via `npm install -g glm-acp-agent@latest`, set `command` to `glm-acp-agent` (no args required).
+- If you built from source, set `command` to `node` and `args` to `["/absolute/path/to/glm-acp-agent/dist/index.js"]`.
+
+Supply `Z_AI_API_KEY` in the environment, or run `glm-acp-agent --setup` once so the agent reads the key from disk on launch.
 
 ### Authentication
 
@@ -353,7 +420,7 @@ The test suite covers:
 
 ## Troubleshooting
 
-- **`No API key found.`** — either set `Z_AI_API_KEY` in the environment, or run `node dist/index.js --setup` (or `glm-acp-agent --setup` if installed globally) once to store the key on disk.
+- **`No API key found.`** — either set `Z_AI_API_KEY` in the environment, or run `glm-acp-agent --setup` (or `node dist/index.js --setup` from a source clone) once to store the key on disk.
 - **`HTTP 401: Invalid API key`** — your key is wrong or expired; rotate it on <https://z.ai/manage-apikey/apikey-list>.
 - **Writes or commands never get to run.** — make sure your ACP client supports `session/request_permission` and that you approve the prompt for the specific tool call.
 

package/dist/index.js

@@ -9,7 +9,7 @@
  * Environment variables:
  *   Z_AI_API_KEY      - API key for the Z.AI / Zhipu AI service. If unset,
  *                       falls back to the credentials file written by --setup.
- *   ACP_GLM_MODEL     - (optional) Override the default model (default: glm-5.1)
+ *   ACP_GLM_MODEL     - (optional) Override the default model (default: glm-5.2)
  */
 import { startConnection } from "./protocol/connection.js";
 import { runSetup } from "./setup.js";
@@ -34,7 +34,7 @@ else if (args.includes("--help") || args.includes("-h")) {
         "",
         "Environment variables:",
         "  Z_AI_API_KEY                   API key (overrides the stored credentials)",
-        "  ACP_GLM_MODEL                  Default model id (e.g. glm-5.1)",
+        "  ACP_GLM_MODEL                  Default model id (e.g. glm-5.2)",
         "  ACP_GLM_AVAILABLE_MODELS       Comma-separated list of advertised models",
         "  ACP_GLM_BASE_URL               Override the Z.AI API base URL",
         "  ACP_GLM_MAX_TOKENS             Per-call max output tokens (default 8192)",

package/dist/llm/glm-client.d.ts

@@ -1,6 +1,32 @@
 import type { ChatCompletionMessageParam } from "openai/resources/index.js";
 import type { ModelInfo, Usage } from "@agentclientprotocol/sdk";
 import { type ToolDefinition } from "../tools/definitions.js";
+/**
+ * Reasoning effort levels exposed to ACP clients via the `thought_level`
+ * SessionConfigOption. These map onto Z.AI's `thinking` / `reasoning_effort`
+ * request parameters (see {@link buildThinkingParams}).
+ *
+ * GLM-5.2 supports three levels: `none`, `high`, `max`. Other thinking-capable
+ * models (GLM-5.1, 5-turbo, 4.7, …) only distinguish thinking on vs. off, so
+ * they use `none` and `on`.
+ */
+export type ThoughtLevel = "none" | "on" | "high" | "max";
+/** Type guard: whether an arbitrary string is a known ThoughtLevel. */
+export declare function isThoughtLevel(value: string): value is ThoughtLevel;
+/**
+ * Resolve which thought-level options a model supports.
+ *
+ * `reasoning_effort` is a GLM-5.2 exclusive per the Z.AI docs — other models
+ * accept the field but it has no effect, so we only expose high/max for 5.2.
+ */
+export declare function getThoughtLevels(model: string): ThoughtLevel[];
+/**
+ * Resolve a stored ThoughtLevel to one that's valid for the given model.
+ * Used when switching models or restoring a persisted session: if the old
+ * level isn't in the new model's option list, fall back to the model's
+ * default (max for 5.2, on for everything else — the last entry in the list).
+ */
+export declare function resolveThoughtLevel(model: string, level: ThoughtLevel): ThoughtLevel;
 /**
  * A single message in the GLM conversation history.
  */
@@ -32,9 +58,22 @@ export interface StreamChatOptions {
     model: string;
     /** Tool schemas available in this specific session. */
     tools?: ToolDefinition[];
+    /** Reasoning effort for this call, or undefined to use the model defaults. */
+    reasoningEffort?: ThoughtLevel;
 }
 /** Default GLM model when neither client nor user has chosen one. */
-export declare const DEFAULT_MODEL = "glm-5.1";
+export declare const DEFAULT_MODEL = "glm-5.2";
+/**
+ * Z.AI / Zhipu AI error code returned when the total prompt length (messages +
+ * tools) exceeds the model's context window.
+ */
+export declare const ERR_CONTEXT_OVERFLOW = 1261;
+export declare function isVisionNativeModel(modelId: string): boolean;
+/**
+ * Resolve the context window size for a given model ID. Falls back to a safe
+ * default (128K) for uncatalogued models.
+ */
+export declare function getContextWindow(modelId: string): number;
 /**
  * Resolve the list of advertised models, allowing the user to override the
  * built-in list via `ACP_GLM_AVAILABLE_MODELS`.
@@ -63,4 +102,23 @@ export declare class GlmClient {
      */
     streamChat(messages: GlmMessage[], signal?: AbortSignal, options?: StreamChatOptions): AsyncGenerator<GlmStreamChunk>;
 }
+/**
+ * Build the Z.AI `thinking` / `reasoning_effort` extra-body params for a call.
+ *
+ * Z.AI exposes two parameters:
+ * - `thinking` — an on/off gate: `{"type":"enabled"}` or `{"type":"disabled"}`
+ * - `reasoning_effort` — GLM-5.2 only; controls thinking depth (`high`/`max`,
+ *   defaulting to `max` when omitted).
+ *
+ * {@link ThoughtLevel} values map as follows:
+ * - `none` → thinking disabled
+ * - `on`   → thinking enabled (no reasoning_effort)
+ * - `high` → thinking enabled + reasoning_effort=high (5.2 only)
+ * - `max`  → thinking enabled + reasoning_effort=max (5.2 only)
+ *
+ * The `ACP_GLM_THINKING` env override still wins: `false` forces thinking off,
+ * `true` forces it on (ignoring a `none` level). When `effort` is unset the
+ * model defaults are used, preserving the pre-thought-level behaviour.
+ */
+export declare function buildThinkingParams(model: string, effort?: ThoughtLevel): Record<string, unknown>;
 //# sourceMappingURL=glm-client.d.ts.map

package/dist/llm/glm-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glm-client.d.ts","sourceRoot":"","sources":["../../src/llm/glm-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAsB,MAAM,2BAA2B,CAAC;AAChG,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAIhF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,0BAA0B,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE;QACT,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,oDAAoD;IACpD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,kCAAkC;IAClC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,4BAA4B;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;CAC1B;AAKD,qEAAqE;AACrE,eAAO,MAAM,aAAa,YAAY,CAAC;AAiCvC;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,SAAS,EAAE,CAYhD;AAED,uEAAuE;AACvE,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;;;;;;GAOG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAS;;IAgB1B;;;;;;OAMG;IACI,UAAU,CACf,QAAQ,EAAE,UAAU,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,cAAc,CAAC,cAAc,CAAC;CA6IlC"}
+{"version":3,"file":"glm-client.d.ts","sourceRoot":"","sources":["../../src/llm/glm-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAsB,MAAM,2BAA2B,CAAC;AAChG,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAIhF;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,KAAK,CAAC;AAgB1D,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAEnE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,EAAE,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,YAAY,CAGpF;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,0BAA0B,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE;QACT,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,oDAAoD;IACpD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,kCAAkC;IAClC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,4BAA4B;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB,8EAA8E;IAC9E,eAAe,CAAC,EAAE,YAAY,CAAC;CAChC;AAKD,qEAAqE;AACrE,eAAO,MAAM,aAAa,YAAY,CAAC;AA2CvC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAiBzC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,SAAS,EAAE,CAYhD;AAED,uEAAuE;AACvE,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;;;;;;GAOG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAS;;IAgB1B;;;;;;OAMG;IACI,UAAU,CACf,QAAQ,EAAE,UAAU,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,cAAc,CAAC,cAAc,CAAC;CA0IlC;AA+BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,YAAY,GACpB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiCzB"}

package/dist/llm/glm-client.js

@@ -2,10 +2,43 @@ import OpenAI from "openai";
 import { TOOL_DEFINITIONS } from "../tools/definitions.js";
 import { resolveApiKey } from "./credentials.js";
 import { debug, error } from "./logger.js";
+/** Levels shown when the selected model is GLM-5.2. */
+const LEVELS_52 = ["none", "high", "max"];
+/** Levels shown for every other thinking-capable model. */
+const LEVELS_DEFAULT = ["none", "on"];
+/** Whether a model id is in the GLM-5.2 family (case-insensitive). */
+function isGlm52(model) {
+    return model.toLowerCase().startsWith("glm-5.2");
+}
+/** The complete set of thought levels the agent understands. */
+const ALL_THOUGHT_LEVELS = ["none", "on", "high", "max"];
+/** Type guard: whether an arbitrary string is a known ThoughtLevel. */
+export function isThoughtLevel(value) {
+    return ALL_THOUGHT_LEVELS.includes(value);
+}
+/**
+ * Resolve which thought-level options a model supports.
+ *
+ * `reasoning_effort` is a GLM-5.2 exclusive per the Z.AI docs — other models
+ * accept the field but it has no effect, so we only expose high/max for 5.2.
+ */
+export function getThoughtLevels(model) {
+    return isGlm52(model) ? LEVELS_52 : LEVELS_DEFAULT;
+}
+/**
+ * Resolve a stored ThoughtLevel to one that's valid for the given model.
+ * Used when switching models or restoring a persisted session: if the old
+ * level isn't in the new model's option list, fall back to the model's
+ * default (max for 5.2, on for everything else — the last entry in the list).
+ */
+export function resolveThoughtLevel(model, level) {
+    const valid = getThoughtLevels(model);
+    return valid.includes(level) ? level : valid[valid.length - 1];
+}
 /** Default base URL for the Z.AI / Zhipu OpenAI-compatible API (Coding endpoint). */
 const DEFAULT_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
 /** Default GLM model when neither client nor user has chosen one. */
-export const DEFAULT_MODEL = "glm-5.1";
+export const DEFAULT_MODEL = "glm-5.2";
 /**
  * Curated list of GLM models the agent advertises to ACP clients via
  * `SessionModelState.availableModels`. Users can override this list via the
@@ -15,16 +48,26 @@ export const DEFAULT_MODEL = "glm-5.1";
  * model pickers.
  */
 const BUILTIN_AVAILABLE_MODELS = [
+    {
+        modelId: "glm-5.2",
+        name: "GLM-5.2",
+        description: "Newest 1M-context coding model with thinking mode",
+    },
     {
         modelId: "glm-5.1",
         name: "GLM-5.1",
-        description: "Latest GLM reasoning model with thinking mode",
+        description: "Long-horizon coding model with thinking mode",
     },
     {
         modelId: "glm-5-turbo",
         name: "GLM-5 Turbo",
         description: "Faster Coding Plan reasoning model",
     },
+    {
+        modelId: "glm-5v-turbo",
+        name: "GLM-5V Turbo",
+        description: "Multimodal Coding Plan model with native vision",
+    },
     {
         modelId: "glm-4.7",
         name: "GLM-4.7",
@@ -36,6 +79,34 @@ const BUILTIN_AVAILABLE_MODELS = [
         description: "Lightweight, lower-latency model",
     },
 ];
+/**
+ * Z.AI / Zhipu AI error code returned when the total prompt length (messages +
+ * tools) exceeds the model's context window.
+ */
+export const ERR_CONTEXT_OVERFLOW = 1261;
+/**
+ * Context window sizes (in tokens) for GLM series models.
+ */
+const MODEL_METADATA = {
+    "glm-5.2": { contextWindow: 1_000_000 },
+    "glm-5.1": { contextWindow: 128_000 },
+    "glm-5-turbo": { contextWindow: 128_000 },
+    "glm-5v-turbo": { contextWindow: 200_000 },
+    "glm-4.7": { contextWindow: 200_000 },
+    "glm-4.5-air": { contextWindow: 128_000 },
+};
+/** Models that accept image content parts directly through chat completions. */
+const VISION_NATIVE_MODELS = new Set(["glm-5v-turbo"]);
+export function isVisionNativeModel(modelId) {
+    return VISION_NATIVE_MODELS.has(modelId.toLowerCase());
+}
+/**
+ * Resolve the context window size for a given model ID. Falls back to a safe
+ * default (128K) for uncatalogued models.
+ */
+export function getContextWindow(modelId) {
+    return MODEL_METADATA[modelId]?.contextWindow ?? 128_000;
+}
 /**
  * Resolve the list of advertised models, allowing the user to override the
  * built-in list via `ACP_GLM_AVAILABLE_MODELS`.
@@ -88,7 +159,7 @@ export class GlmClient {
      */
     async *streamChat(messages, signal, options) {
         const model = options?.model ?? getDefaultModel();
-        const thinkingEnabled = parseThinking(model);
+        const thinkingParams = buildThinkingParams(model, options?.reasoningEffort);
         const tools = (options?.tools ?? TOOL_DEFINITIONS).map((t) => ({
             type: "function",
             function: {
@@ -97,13 +168,10 @@ export class GlmClient {
                 parameters: t.function.parameters,
             },
         }));
-        debug(`streamChat: model=${model} baseURL=${this.client.baseURL} messages=${messages.length} tools=${tools.length} thinking=${thinkingEnabled}`);
+        debug(`streamChat: model=${model} baseURL=${this.client.baseURL} messages=${messages.length} tools=${tools.length} thinking=${JSON.stringify(thinkingParams)}`);
         // The OpenAI SDK forwards unknown extra body fields verbatim, so we use
-        // that to pass GLM-specific fields like `thinking`.
-        const extraBody = {};
-        if (thinkingEnabled) {
-            extraBody["thinking"] = { type: "enabled" };
-        }
+        // that to pass GLM-specific fields like `thinking` and `reasoning_effort`.
+        const extraBody = { ...thinkingParams };
         let stream;
         try {
             stream = await this.client.chat.completions.create({
@@ -201,17 +269,69 @@ function parseIntEnv(name, fallback) {
     return Number.isFinite(n) && n > 0 ? n : fallback;
 }
 /**
- * Decide whether to enable GLM "thinking" mode for a given model name.
- *
- * The user can force on/off via `ACP_GLM_THINKING=true|false`. Otherwise,
- * we enable thinking for any model whose name suggests it supports it
+ * Decide whether a model supports GLM "thinking" mode based on its name
  * (the GLM-4.5 / GLM-4.6 / GLM-4.7 / GLM-5.x families).
  */
-function parseThinking(model) {
+function modelSupportsThinking(model) {
+    return /^glm-(?:4\.[567]|5)/i.test(model);
+}
+/**
+ * Parse the `ACP_GLM_THINKING` env override into an explicit boolean, or
+ * `undefined` when the variable is unset. `true`/`1` force thinking on;
+ * anything else forces it off.
+ */
+function thinkingOverride() {
     const override = process.env["ACP_GLM_THINKING"];
     if (override !== undefined) {
         return override.toLowerCase() === "true" || override === "1";
     }
-    return /^glm-(?:4\.[567]|5)/i.test(model);
+    return undefined;
+}
+/**
+ * Build the Z.AI `thinking` / `reasoning_effort` extra-body params for a call.
+ *
+ * Z.AI exposes two parameters:
+ * - `thinking` — an on/off gate: `{"type":"enabled"}` or `{"type":"disabled"}`
+ * - `reasoning_effort` — GLM-5.2 only; controls thinking depth (`high`/`max`,
+ *   defaulting to `max` when omitted).
+ *
+ * {@link ThoughtLevel} values map as follows:
+ * - `none` → thinking disabled
+ * - `on`   → thinking enabled (no reasoning_effort)
+ * - `high` → thinking enabled + reasoning_effort=high (5.2 only)
+ * - `max`  → thinking enabled + reasoning_effort=max (5.2 only)
+ *
+ * The `ACP_GLM_THINKING` env override still wins: `false` forces thinking off,
+ * `true` forces it on (ignoring a `none` level). When `effort` is unset the
+ * model defaults are used, preserving the pre-thought-level behaviour.
+ */
+export function buildThinkingParams(model, effort) {
+    const params = {};
+    const override = thinkingOverride();
+    const modelCanThink = modelSupportsThinking(model);
+    // Explicit env override to disable wins over everything.
+    if (override === false) {
+        if (modelCanThink)
+            params["thinking"] = { type: "disabled" };
+        return params;
+    }
+    const canThink = override === true || modelCanThink;
+    // A `none` level disables thinking, unless the env override forces it on.
+    if (effort === "none" && override !== true) {
+        if (canThink)
+            params["thinking"] = { type: "disabled" };
+        return params;
+    }
+    if (!canThink)
+        return params;
+    params["thinking"] = { type: "enabled" };
+    // reasoning_effort is only meaningful for GLM-5.2 per the Z.AI docs, and Z.AI
+    // only accepts the "high"/"max" values there. Other levels ("on", and "none"
+    // when thinking is force-enabled via the env override) carry no valid
+    // reasoning_effort, so we omit the field entirely.
+    if ((effort === "high" || effort === "max") && isGlm52(model)) {
+        params["reasoning_effort"] = effort;
+    }
+    return params;
 }
 //# sourceMappingURL=glm-client.js.map