glm-acp-agent 1.1.2 → 1.1.4

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, } 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";
@@ -74,8 +74,9 @@ export class GlmAcpAgent {
     async initialize(params) {
         // Negotiate the lowest version both sides support.
         const negotiatedVersion = params.protocolVersion <= VERSION ? params.protocolVersion : VERSION;
-        // Track client capabilities so we can adapt tool calls to what the client
-        // actually supports.
+        // Keep client capabilities for compatibility with ACP initialize payloads.
+        // Built-in local tools run in this agent process and are not gated on
+        // client fs/terminal support.
         this.clientCapabilities = params.clientCapabilities ?? null;
         return {
             protocolVersion: negotiatedVersion,
@@ -118,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,
@@ -134,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) {
@@ -165,10 +167,12 @@ export class GlmAcpAgent {
             model,
             toolDefinitions,
             mcpTools,
+            mode: "default",
         });
         return {
             sessionId,
             models: this.modelsState(model),
+            modes: this.modesState("default"),
         };
     }
     async unstable_setSessionModel(params) {
@@ -203,9 +207,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 {};
     }
     // ---------------------------------------------------------------------------
@@ -243,18 +287,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.
@@ -405,13 +452,17 @@ export class GlmAcpAgent {
             model: persisted.model,
             toolDefinitions,
             mcpTools,
+            mode: persisted.mode,
         };
         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),
+        };
     }
     async unstable_forkSession(params) {
         const source = this.sessions.get(params.sessionId);
@@ -433,12 +484,14 @@ export class GlmAcpAgent {
             model: persisted.model,
             toolDefinitions,
             mcpTools,
+            mode: persisted.mode,
         };
         this.sessions.set(newSessionId, forked);
         this.persistSession(newSessionId, forked);
         return {
             sessionId: newSessionId,
             models: this.modelsState(forked.model),
+            modes: this.modesState(forked.mode),
         };
     }
     async resumeSession(params) {
@@ -456,11 +509,15 @@ export class GlmAcpAgent {
             model: persisted.model,
             toolDefinitions,
             mcpTools,
+            mode: persisted.mode,
         };
         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),
+        };
     }
     // ---------------------------------------------------------------------------
     // Persistence helpers
@@ -473,6 +530,7 @@ export class GlmAcpAgent {
             title: session.title,
             updatedAt: session.updatedAt,
             model: session.model,
+            mode: session.mode,
         };
     }
     persistSession(sessionId, session) {
@@ -545,53 +603,89 @@ 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);
+        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,
+                })) {
+                    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);
-                }
-                if (chunk.usage) {
-                    lastUsage = chunk.usage;
+                else if (isOverflow) {
+                    throw new Error("Context overflow persisted after emergency compaction", { cause: err });
                 }
-                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) {
@@ -646,27 +740,9 @@ export class GlmAcpAgent {
                 return "end_turn";
         }
     }
-    /** Tool schemas we expose given the client's capabilities and session MCP tools. */
+    /** Tool schemas we expose for agent-owned local tools plus session MCP tools. */
     availableToolDefinitions(mcpTools = null) {
-        // If the client never sent capabilities at all (initialize wasn't called,
-        // or it omitted the field), advertise the full set so the system prompt
-        // still mentions every tool. The executor will surface a clean error if
-        // the model invokes one whose capability is missing.
-        if (!this.clientCapabilities) {
-            return [...TOOL_DEFINITIONS, ...(mcpTools?.toolDefinitions ?? [])];
-        }
-        const fs = this.clientCapabilities.fs ?? {};
-        const terminal = this.clientCapabilities.terminal ?? false;
-        const names = [];
-        if (fs.readTextFile)
-            names.push("read_file");
-        if (fs.writeTextFile)
-            names.push("write_file");
-        if (terminal)
-            names.push("list_files", "run_command");
-        // Web tools and image_analysis run inside the agent process, so they are
-        // unconditional except when vision is explicitly disabled.
-        names.push("web_search", "web_reader");
+        const names = ["read_file", "write_file", "list_files", "run_command", "web_search", "web_reader"];
         if (this.visionClientExplicit ? this._visionClient !== null : true) {
             names.push("image_analysis");
         }
@@ -719,9 +795,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
@@ -757,4 +939,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