glm-acp-agent 1.1.3 → 1.2.0

package/dist/protocol/agent.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join as pathJoin } from "node:path";
 import { PROTOCOL_VERSION as VERSION } from "@agentclientprotocol/sdk";
-import { GlmClient, getAvailableModels, getDefaultModel, } from "../llm/glm-client.js";
+import { GlmClient, getAvailableModels, getDefaultModel, getContextWindow, isVisionNativeModel, ERR_CONTEXT_OVERFLOW, getThoughtLevels, resolveThoughtLevel, isThoughtLevel, } from "../llm/glm-client.js";
 import { ToolExecutor } from "../tools/executor.js";
 import { TOOL_DEFINITIONS } from "../tools/definitions.js";
 import { connectSessionMcpServers } from "../tools/session-mcp-client.js";
@@ -119,7 +119,7 @@ export class GlmAcpAgent {
                 promptCapabilities: {
                     // Baseline (text + resource_link) is implicit; we additionally accept
                     // embedded resources for inline file context, plus images for
-                    // vision-capable GLM models (e.g. glm-4v-plus).
+                    // glm-5v-turbo native vision and the Vision MCP fallback path.
                     // Set ACP_GLM_PROMPT_IMAGES=false (or =0) to stop advertising image
                     // support so clients like Zed won't offer the image-attachment UI.
                     embeddedContext: true,
@@ -135,11 +135,12 @@ export class GlmAcpAgent {
             },
         };
     }
-    async authenticate(_params) {
+    async authenticate(params) {
         // Authentication is configured externally — either via Z_AI_API_KEY in the
         // environment or via the credentials file written by `glm-acp-agent --setup`.
         // The agent has nothing to do here; failures will surface when the model
         // is first called.
+        void params;
         return {};
     }
     async newSession(params) {
@@ -156,6 +157,10 @@ export class GlmAcpAgent {
             }),
         };
         const model = getDefaultModel();
+        // Default to the model's own default effort ("max" for 5.2, "on"
+        // otherwise) so out-of-the-box behaviour matches the pre-thought-level
+        // default (thinking on, no explicit reasoning_effort).
+        const thoughtLevel = resolveThoughtLevel(model, "max");
         this.sessions.set(sessionId, {
             cwd: params.cwd,
             messages: [systemPrompt],
@@ -166,10 +171,14 @@ export class GlmAcpAgent {
             model,
             toolDefinitions,
             mcpTools,
+            mode: "default",
+            thoughtLevel,
         });
         return {
             sessionId,
             models: this.modelsState(model),
+            modes: this.modesState("default"),
+            configOptions: this.configOptionsState(model, thoughtLevel),
         };
     }
     async unstable_setSessionModel(params) {
@@ -185,7 +194,14 @@ export class GlmAcpAgent {
             process.stderr.write(`[glm-acp-agent] warning: model "${params.modelId}" is not in the advertised list; using as-is.\n`);
         }
         session.model = params.modelId;
+        // The valid thought levels differ per model (e.g. 5.2 offers high/max
+        // while others only offer none/on), so clamp the current level to what
+        // the new model supports.
+        session.thoughtLevel = resolveThoughtLevel(params.modelId, session.thoughtLevel);
         session.updatedAt = new Date().toISOString();
+        // Persist immediately so a fork/reload before the next prompt doesn't
+        // resurrect the previous model or thought level (matches setSessionConfigOption).
+        this.persistSession(params.sessionId, session);
         // Notify clients so any UI that displays the active model refreshes
         // immediately, instead of waiting for the next prompt to complete.
         await safeSessionUpdate(this.connection, {
@@ -195,8 +211,66 @@ export class GlmAcpAgent {
                 updatedAt: session.updatedAt,
             },
         });
+        // Push updated thought_level options — the set of valid levels may
+        // differ between models (e.g. switching from 5.2 to 4.7 drops "high").
+        await safeSessionUpdate(this.connection, {
+            sessionId: params.sessionId,
+            update: {
+                sessionUpdate: "config_option_update",
+                configOptions: this.configOptionsState(session.model, session.thoughtLevel),
+            },
+        });
         return {};
     }
+    /**
+     * Build the `thought_level` SessionConfigOption for the given model. The
+     * available levels depend on the model (see {@link getThoughtLevels}).
+     */
+    configOptionsState(model, thoughtLevel) {
+        const levels = getThoughtLevels(model);
+        return [
+            {
+                id: "thought_level",
+                name: "Thinking",
+                description: "Reasoning effort",
+                category: "thought_level",
+                type: "select",
+                currentValue: thoughtLevel,
+                options: levels.map((level) => ({
+                    value: level,
+                    name: level === "none"
+                        ? "Off"
+                        : level === "on"
+                            ? "On"
+                            : level.charAt(0).toUpperCase() + level.slice(1),
+                })),
+            },
+        ];
+    }
+    async setSessionConfigOption(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${params.sessionId}`);
+        }
+        if (params.configId !== "thought_level") {
+            throw new Error(`Unknown config option: ${params.configId}`);
+        }
+        // Reject values that aren't a thought level at all (typos, stale ids from
+        // another agent version) rather than silently coercing them.
+        if (typeof params.value !== "string" || !isThoughtLevel(params.value)) {
+            throw new Error(`Invalid thought_level value: ${String(params.value)}`);
+        }
+        // Auto-resolve a *known* level that isn't valid for the current model to
+        // that model's default. This happens when a client caches a thoughtLevel
+        // from a previous session (or model) and re-sends it for a model with a
+        // different level set (e.g. "max" from glm-5.2 sent while on glm-4.7).
+        session.thoughtLevel = resolveThoughtLevel(session.model, params.value);
+        session.updatedAt = new Date().toISOString();
+        this.persistSession(params.sessionId, session);
+        return {
+            configOptions: this.configOptionsState(session.model, session.thoughtLevel),
+        };
+    }
     /** Build the SessionModelState we advertise on session create/load/resume/fork. */
     modelsState(currentModelId) {
         return {
@@ -204,9 +278,49 @@ export class GlmAcpAgent {
             currentModelId,
         };
     }
-    async setSessionMode(_params) {
-        // We don't advertise modes; this is a no-op accepting any request the
-        // client might send.
+    /** Build the SessionModeState we advertise on session create/load/resume/fork. */
+    modesState(currentModeId) {
+        return {
+            availableModes: [
+                {
+                    id: "default",
+                    name: "Ask for permission",
+                    description: "Prompt before edits and commands.",
+                },
+                {
+                    id: "accept_edits",
+                    name: "Auto-approve edits",
+                    description: "Edits run without prompting. Commands still prompt.",
+                },
+                {
+                    id: "bypass_permissions",
+                    name: "Bypass all permissions",
+                    description: "Edits and commands run without prompting.",
+                },
+            ],
+            currentModeId,
+        };
+    }
+    async setSessionMode(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${params.sessionId}`);
+        }
+        const validModeIds = ["default", "accept_edits", "bypass_permissions"];
+        if (!validModeIds.includes(params.modeId)) {
+            throw new Error(`Invalid modeId: ${params.modeId}. Valid modes are: ${validModeIds.join(", ")}`);
+        }
+        const newMode = params.modeId;
+        session.mode = newMode;
+        session.updatedAt = new Date().toISOString();
+        this.persistSession(params.sessionId, session);
+        await safeSessionUpdate(this.connection, {
+            sessionId: params.sessionId,
+            update: {
+                sessionUpdate: "current_mode_update",
+                currentModeId: newMode,
+            },
+        });
         return {};
     }
     // ---------------------------------------------------------------------------
@@ -244,18 +358,21 @@ export class GlmAcpAgent {
         else if (connSignal?.aborted) {
             abortController.abort();
         }
-        // Convert ACP content blocks into a GLM user message. Baseline: text +
-        // resource_link. Optional: embedded resources. Image blocks are routed
-        // through Z.AI Coding Plan Vision MCP (see image-preprocessor) so the
-        // result is always a plain string for the chat-completions endpoint.
+        // Convert ACP content blocks into a GLM user message. Most models receive
+        // plain text, with images preprocessed through Vision MCP. Native vision
+        // models receive OpenAI-style multimodal content parts directly.
         if (isDebugEnabled()) {
             for (const line of buildPromptBlockDiagnosticLines(params.prompt)) {
                 debug(line);
             }
         }
-        let preprocessed;
-        preprocessed = await preprocessImageBlocks(params.prompt, this.visionClient, abortController.signal);
-        const { content: userContent, plainText: userText } = renderPromptBlocks(preprocessed.blocks);
+        const visionNative = isVisionNativeModel(session.model);
+        const preprocessed = visionNative
+            ? { blocks: params.prompt, cleanups: [] }
+            : await preprocessImageBlocks(params.prompt, this.visionClient, abortController.signal);
+        const { content: userContent, plainText: userText } = visionNative
+            ? renderVisionNativePromptBlocks(preprocessed.blocks)
+            : renderPromptBlocks(preprocessed.blocks);
         session.messages.push({ role: "user", content: userContent });
         // Echo back the client-supplied messageId on every response (success,
         // cancelled, or error) so the client can correlate the turn.
@@ -406,13 +523,19 @@ export class GlmAcpAgent {
             model: persisted.model,
             toolDefinitions,
             mcpTools,
+            mode: persisted.mode,
+            thoughtLevel: resolveThoughtLevel(persisted.model, persisted.thoughtLevel ?? "max"),
         };
         this.sessions.set(params.sessionId, restored);
         // Replay user/assistant text turns so the client can rehydrate its UI.
         // Tool / system messages are skipped — they're internal and the client
         // doesn't render them on its own.
         await this.replayMessages(params.sessionId, persisted.messages);
-        return { models: this.modelsState(persisted.model) };
+        return {
+            models: this.modelsState(persisted.model),
+            modes: this.modesState(persisted.mode),
+            configOptions: this.configOptionsState(restored.model, restored.thoughtLevel),
+        };
     }
     async unstable_forkSession(params) {
         const source = this.sessions.get(params.sessionId);
@@ -434,12 +557,16 @@ export class GlmAcpAgent {
             model: persisted.model,
             toolDefinitions,
             mcpTools,
+            mode: persisted.mode,
+            thoughtLevel: resolveThoughtLevel(persisted.model, persisted.thoughtLevel ?? "max"),
         };
         this.sessions.set(newSessionId, forked);
         this.persistSession(newSessionId, forked);
         return {
             sessionId: newSessionId,
             models: this.modelsState(forked.model),
+            modes: this.modesState(forked.mode),
+            configOptions: this.configOptionsState(forked.model, forked.thoughtLevel),
         };
     }
     async resumeSession(params) {
@@ -457,11 +584,17 @@ export class GlmAcpAgent {
             model: persisted.model,
             toolDefinitions,
             mcpTools,
+            mode: persisted.mode,
+            thoughtLevel: resolveThoughtLevel(persisted.model, persisted.thoughtLevel ?? "max"),
         };
         this.sessions.set(params.sessionId, restored);
         // Resume does NOT replay history — the client keeps its own UI state and
         // just wants the agent to pick up where it left off.
-        return { models: this.modelsState(persisted.model) };
+        return {
+            models: this.modelsState(persisted.model),
+            modes: this.modesState(persisted.mode),
+            configOptions: this.configOptionsState(restored.model, restored.thoughtLevel),
+        };
     }
     // ---------------------------------------------------------------------------
     // Persistence helpers
@@ -474,6 +607,8 @@ export class GlmAcpAgent {
             title: session.title,
             updatedAt: session.updatedAt,
             model: session.model,
+            mode: session.mode,
+            thoughtLevel: session.thoughtLevel,
         };
     }
     persistSession(sessionId, session) {
@@ -546,53 +681,90 @@ export class GlmAcpAgent {
      * Returns the ACP stop reason and optional token usage reported by the model.
      */
     async runPromptLoop(sessionId, session, signal) {
-        const executor = new ToolExecutor(this.connection, sessionId, this.clientCapabilities, signal, this.visionClient, session.mcpTools, session.cwd);
+        const executor = new ToolExecutor(this.connection, sessionId, this.clientCapabilities, signal, this.visionClient, session.mcpTools, session.cwd, 
+        // Use a thunk so mode changes mid-turn take effect on the next tool call.
+        () => this.sessions.get(sessionId)?.mode ?? "default");
         let lastUsage;
+        let overflowRetryCount = 0;
         for (let turn = 0; turn < this.maxTurns; turn++) {
             if (signal.aborted)
                 return { stopReason: "cancelled" };
+            // Proactive compaction: check if history exceeds 90% of context window.
+            const window = getContextWindow(session.model);
+            const limit = Math.floor(window * 0.9);
+            if (estimateTokens(session.messages) > limit) {
+                session.messages = compactMessages(session.messages, Math.floor(window * 0.8));
+            }
             debug(`promptLoop: turn=${turn} session=${sessionId} model=${session.model} messages=${session.messages.length}`);
             const toolCalls = [];
             let assistantText = "";
             let lastStopReason;
-            // Stream the GLM response. The session's currently-selected model wins;
-            // it's mutated by `unstable_setSessionModel` between turns.
-            for await (const chunk of this.glm.streamChat(session.messages, signal, {
-                model: session.model,
-                tools: session.toolDefinitions,
-            })) {
+            let retryTurn = false;
+            try {
+                // Stream the GLM response. The session's currently-selected model wins;
+                // it's mutated by `unstable_setSessionModel` between turns.
+                for await (const chunk of this.glm.streamChat(session.messages, signal, {
+                    model: session.model,
+                    tools: session.toolDefinitions,
+                    reasoningEffort: session.thoughtLevel,
+                })) {
+                    if (signal.aborted)
+                        return { stopReason: "cancelled" };
+                    if (chunk.thinking) {
+                        await this.connection.sessionUpdate({
+                            sessionId,
+                            update: {
+                                sessionUpdate: "agent_thought_chunk",
+                                content: { type: "text", text: chunk.thinking },
+                            },
+                        });
+                    }
+                    if (chunk.text) {
+                        assistantText += chunk.text;
+                        await this.connection.sessionUpdate({
+                            sessionId,
+                            update: {
+                                sessionUpdate: "agent_message_chunk",
+                                content: { type: "text", text: chunk.text },
+                            },
+                        });
+                    }
+                    if (chunk.toolCall) {
+                        debug(`promptLoop: toolCall id=${chunk.toolCall.id} name=${chunk.toolCall.name}`);
+                        toolCalls.push(chunk.toolCall);
+                    }
+                    if (chunk.usage) {
+                        lastUsage = chunk.usage;
+                    }
+                    if (chunk.done) {
+                        lastStopReason = chunk.stopReason;
+                    }
+                }
+            }
+            catch (err) {
                 if (signal.aborted)
                     return { stopReason: "cancelled" };
-                if (chunk.thinking) {
-                    await this.connection.sessionUpdate({
-                        sessionId,
-                        update: {
-                            sessionUpdate: "agent_thought_chunk",
-                            content: { type: "text", text: chunk.thinking },
-                        },
-                    });
+                const body = err?.error;
+                const isOverflow = body?.code === ERR_CONTEXT_OVERFLOW ||
+                    body?.code === String(ERR_CONTEXT_OVERFLOW);
+                if (isOverflow && overflowRetryCount < 1) {
+                    debug(`promptLoop: context overflow (1261) detected, performing emergency compaction`);
+                    const window = getContextWindow(session.model);
+                    session.messages = compactMessages(session.messages, Math.floor(window * 0.7));
+                    overflowRetryCount++;
+                    retryTurn = true;
                 }
-                if (chunk.text) {
-                    assistantText += chunk.text;
-                    await this.connection.sessionUpdate({
-                        sessionId,
-                        update: {
-                            sessionUpdate: "agent_message_chunk",
-                            content: { type: "text", text: chunk.text },
-                        },
-                    });
-                }
-                if (chunk.toolCall) {
-                    debug(`promptLoop: toolCall id=${chunk.toolCall.id} name=${chunk.toolCall.name}`);
-                    toolCalls.push(chunk.toolCall);
+                else if (isOverflow) {
+                    throw new Error("Context overflow persisted after emergency compaction", { cause: err });
                 }
-                if (chunk.usage) {
-                    lastUsage = chunk.usage;
-                }
-                if (chunk.done) {
-                    lastStopReason = chunk.stopReason;
+                else {
+                    throw err;
                 }
             }
+            if (retryTurn) {
+                turn--; // Re-run the same turn index
+                continue;
+            }
             // Record the assistant turn in history so the model has full context for
             // the next iteration.
             if (toolCalls.length > 0) {
@@ -702,9 +874,115 @@ function renderPromptBlocks(blocks) {
     const plainText = textParts.join("\n");
     return { content: plainText, plainText };
 }
+function renderVisionNativePromptBlocks(blocks) {
+    const content = [];
+    const plainTextParts = [];
+    let imageIndex = 0;
+    const pushText = (text) => {
+        if (text.length === 0)
+            return;
+        content.push({ type: "text", text });
+        plainTextParts.push(text);
+    };
+    for (const block of blocks) {
+        switch (block.type) {
+            case "text":
+                pushText(block.text);
+                break;
+            case "resource_link":
+                pushText(`[${block.name}](${block.uri})`);
+                break;
+            case "resource": {
+                const res = block.resource;
+                if ("text" in res && typeof res.text === "string") {
+                    pushText(`<resource uri="${res.uri}">\n${res.text}\n</resource>`);
+                }
+                else if ("blob" in res) {
+                    pushText(`[binary resource](${res.uri})`);
+                }
+                break;
+            }
+            case "image": {
+                imageIndex += 1;
+                const imageUrl = toVisionNativeImageUrl(block);
+                if (imageUrl) {
+                    content.push({ type: "image_url", image_url: { url: imageUrl } });
+                    plainTextParts.push(`[image: ${block.mimeType}]`);
+                }
+                else {
+                    pushText(`<image_unsupported_format index="${imageIndex}" mime="${escapeAttribute(block.mimeType)}">Only image/jpeg, image/jpg, image/png inputs can be sent to the native vision model. Attach a supported HTTPS image URL or supported base64 image data.</image_unsupported_format>`);
+                }
+                break;
+            }
+            case "audio":
+                pushText("[unsupported audio block]");
+                break;
+            default:
+                pushText(`[unknown block type ${block.type}]`);
+        }
+    }
+    return { content, plainText: plainTextParts.join("\n") };
+}
+function toVisionNativeImageUrl(block) {
+    if (!isSupportedVisionMime(block.mimeType))
+        return null;
+    if (typeof block.uri === "string" && block.uri.length > 0) {
+        if (block.uri.startsWith("data:"))
+            return block.uri;
+        try {
+            const url = new URL(block.uri);
+            if (url.protocol === "https:")
+                return block.uri;
+        }
+        catch {
+            // Fall through to inline data when available.
+        }
+    }
+    if (typeof block.data === "string" && block.data.length > 0) {
+        return `data:${block.mimeType.toLowerCase()};base64,${block.data}`;
+    }
+    return null;
+}
+function isSupportedVisionMime(mimeType) {
+    switch (mimeType.toLowerCase()) {
+        case "image/jpeg":
+        case "image/jpg":
+        case "image/png":
+            return true;
+        default:
+            return false;
+    }
+}
+function escapeAttribute(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
 /** Flatten the `content` of a user message into a plain string for replay. */
 function stringifyUserMessage(content) {
-    return typeof content === "string" ? content : "";
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (typeof part === "object" &&
+            part !== null &&
+            part.type === "text" &&
+            typeof part.text === "string") {
+            return part.text;
+        }
+        if (typeof part === "object" &&
+            part !== null &&
+            part.type === "image_url") {
+            return "[image]";
+        }
+        return "";
+    })
+        .filter((text) => text.length > 0)
+        .join("\n");
 }
 /**
  * Read an `AGENTS.md` (preferred) or `CLAUDE.md` from the session's cwd, returning
@@ -740,4 +1018,99 @@ async function safeSessionUpdate(connection, params) {
         // best-effort
     }
 }
+/**
+ * Heuristically estimate the number of tokens in a list of messages.
+ * Uses a simple 4-character-per-token rule, which is a safe baseline for
+ * English and code.
+ */
+function estimateTokens(messages) {
+    let chars = 0;
+    for (const m of messages) {
+        if (typeof m.content === "string") {
+            chars += m.content.length;
+        }
+        else if (Array.isArray(m.content)) {
+            for (const part of m.content) {
+                if ("text" in part && typeof part.text === "string") {
+                    chars += part.text.length;
+                }
+            }
+        }
+        if (m.role === "assistant" && m.tool_calls) {
+            for (const tc of m.tool_calls) {
+                if ("function" in tc) {
+                    chars += tc.function.name.length;
+                    chars += tc.function.arguments.length;
+                }
+            }
+        }
+    }
+    return Math.ceil(chars / 4);
+}
+/**
+ * Prune message history to stay within a target token limit.
+ *
+ * Strategy:
+ * 1. Always keep the System prompt (index 0).
+ * 2. Always keep the last `preserveTurns` interaction groups (default 10) to
+ *    maintain conversation flow. An interaction group (turn) typically starts
+ *    with a user message followed by assistant and tool responses.
+ * 3. Evict the largest remaining interaction groups until the total estimate
+ *    is below `targetTokens`.
+ */
+function compactMessages(messages, targetTokens, preserveTurns = 10) {
+    if (messages.length <= 1)
+        return messages;
+    const systemPrompt = messages[0];
+    const remaining = messages.slice(1);
+    // Group messages into interaction turns. A turn starts with a "user" message.
+    const turns = [];
+    let currentTurn = [];
+    for (const m of remaining) {
+        if (m.role === "user" && currentTurn.length > 0) {
+            turns.push(currentTurn);
+            currentTurn = [];
+        }
+        currentTurn.push(m);
+    }
+    if (currentTurn.length > 0) {
+        turns.push(currentTurn);
+    }
+    // If we have fewer turns than we want to preserve, just return the messages.
+    if (turns.length <= preserveTurns)
+        return messages;
+    let currentEstimate = estimateTokens(messages);
+    if (currentEstimate <= targetTokens)
+        return messages;
+    debug(`compactMessages: currentEstimate=${currentEstimate} target=${targetTokens} turns=${turns.length}`);
+    // Identify candidates for eviction: all turns except the last `preserveTurns`.
+    const tail = turns.slice(-preserveTurns);
+    const candidateTurns = turns
+        .slice(0, -preserveTurns)
+        .map((turn, index) => ({
+        turn,
+        index,
+        tokens: estimateTokens(turn),
+    }));
+    // Sort candidates by size (largest first).
+    candidateTurns.sort((a, b) => b.tokens - a.tokens);
+    const evictedIndices = new Set();
+    for (const c of candidateTurns) {
+        if (currentEstimate <= targetTokens)
+            break;
+        evictedIndices.add(c.index);
+        currentEstimate -= c.tokens;
+    }
+    const compacted = [systemPrompt];
+    for (let i = 0; i < turns.length - preserveTurns; i++) {
+        if (!evictedIndices.has(i)) {
+            compacted.push(...turns[i]);
+        }
+    }
+    for (const turn of tail) {
+        compacted.push(...turn);
+    }
+    debug(`compactMessages: done, newEstimate=${estimateTokens(compacted)} messageCount=${compacted.length}`);
+    return compacted;
+}
 //# sourceMappingURL=agent.js.map