glm-acp-agent 1.1.3 → 1.2.0

package/dist/tests/agent.test.js

@@ -620,7 +620,8 @@ test("system prompt includes image_handling fallback instructions", async () =>
     const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
     await agent.prompt({ sessionId, prompt: [{ type: "text", text: "hi" }] });
     assert.ok(ref.value.includes("<image_handling>"), "system prompt must contain image_handling section");
-    assert.ok(ref.value.includes("image_analysis_error") || ref.value.includes("image_analysis"), "image_handling must mention the known annotation tags");
+    assert.ok(ref.value.toLowerCase().includes("native multimodal image content"), "image_handling must cover native multimodal image delivery");
+    assert.ok(ref.value.includes("image_analysis_error") && ref.value.includes("image_unsupported_format"), "image_handling must mention image annotation fallback tags");
     assert.ok(ref.value.toLowerCase().includes("client"), "image_handling must attribute missing image to client-side problem");
 });
 test("image_analysis tool is still listed when ACP_GLM_PROMPT_IMAGES=false", async () => {
@@ -675,13 +676,215 @@ test("authenticate is a no-op", async () => {
     const result = await agent.authenticate({ methodId: "z_ai_api_key" });
     assert.deepEqual(result, {});
 });
-test("setSessionMode is a no-op", async () => {
+test("setSessionMode persists the mode and emits current_mode_update", async () => {
+    const { store, cleanup } = makeTempStore();
+    try {
+        const conn = createConnectionStub();
+        const agent = new GlmAcpAgent(conn, { sessionStore: store });
+        await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+        const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+        // Close the session to persist it
+        await agent.closeSession({ sessionId });
+        // Default mode is "default" after persistence
+        const initial = store.load(sessionId);
+        assert.equal(initial?.mode, "default");
+        // Load the session back
+        const loadResult = await agent.loadSession({ sessionId, cwd: "/tmp", mcpServers: [] });
+        assert.equal(loadResult.modes?.currentModeId, "default");
+        // Change to accept_edits
+        const before = conn.updates.length;
+        const result = await agent.setSessionMode({ sessionId, modeId: "accept_edits" });
+        assert.deepEqual(result, {});
+        // Check that the mode was persisted
+        const after = store.load(sessionId);
+        assert.equal(after?.mode, "accept_edits");
+        // Check that current_mode_update was emitted
+        const modeUpdates = conn.updates.slice(before).filter((u) => u.update.sessionUpdate === "current_mode_update");
+        assert.equal(modeUpdates.length, 1);
+        assert.equal(modeUpdates[0].update.currentModeId, "accept_edits");
+    }
+    finally {
+        cleanup();
+    }
+});
+test("setSessionMode rejects invalid mode ids", async () => {
     const conn = createConnectionStub();
     const agent = new GlmAcpAgent(conn, { sessionStore: null });
     await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
     const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
-    const result = await agent.setSessionMode({ sessionId, modeId: "ask" });
-    assert.deepEqual(result, {});
+    await assert.rejects(agent.setSessionMode({ sessionId, modeId: "invalid_mode" }), /Invalid modeId: invalid_mode/);
+});
+// ---------------------------------------------------------------------------
+// Thought level / config options
+// ---------------------------------------------------------------------------
+test("newSession returns configOptions with thought_level selector for default model", async () => {
+    const conn = createConnectionStub();
+    const agent = new GlmAcpAgent(conn, { sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const result = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    assert.ok(result.configOptions, "configOptions should be present");
+    const tl = result.configOptions.find((o) => o.category === "thought_level");
+    assert.ok(tl, "thought_level option should exist");
+    assert.equal(tl.type, "select");
+    // Default model is glm-5.2 → none/high/max, defaulting to max.
+    assert.equal(tl.currentValue, "max");
+    const values = tl.options.map((o) => o.value);
+    assert.deepEqual(values, ["none", "high", "max"]);
+});
+test("setSessionConfigOption updates thoughtLevel and returns updated options", async () => {
+    const conn = createConnectionStub();
+    const agent = new GlmAcpAgent(conn, { sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    const result = await agent.setSessionConfigOption({
+        sessionId,
+        configId: "thought_level",
+        value: "high",
+    });
+    assert.ok(result.configOptions);
+    const tl = result.configOptions.find((o) => o.id === "thought_level");
+    assert.equal(tl.currentValue, "high");
+});
+test("setSessionConfigOption auto-resolves values invalid for the current model", async () => {
+    const conn = createConnectionStub();
+    const agent = new GlmAcpAgent(conn, { sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    // Switch to glm-5.1 which only supports none/on.
+    await agent.unstable_setSessionModel({ sessionId, modelId: "glm-5.1" });
+    // "max" is invalid for glm-5.1 — should auto-resolve to "on".
+    const result = await agent.setSessionConfigOption({
+        sessionId,
+        configId: "thought_level",
+        value: "max",
+    });
+    const tl = result.configOptions.find((o) => o.id === "thought_level");
+    assert.equal(tl.currentValue, "on");
+});
+test("setSessionConfigOption rejects unknown config ids", async () => {
+    const conn = createConnectionStub();
+    const agent = new GlmAcpAgent(conn, { sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    await assert.rejects(agent.setSessionConfigOption({ sessionId, configId: "unknown", value: "x" }), /Unknown config option/);
+});
+test("setSessionConfigOption rejects values that aren't a known thought level", async () => {
+    const conn = createConnectionStub();
+    const agent = new GlmAcpAgent(conn, { sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    // "medium" is not a ThoughtLevel at all — reject rather than silently coerce.
+    await assert.rejects(agent.setSessionConfigOption({ sessionId, configId: "thought_level", value: "medium" }), /Invalid thought_level value/);
+    // A cross-model-but-known value ("max" while on the default glm-5.2) is fine.
+    const ok = await agent.setSessionConfigOption({
+        sessionId,
+        configId: "thought_level",
+        value: "max",
+    });
+    assert.equal(ok.configOptions.find((o) => o.id === "thought_level").currentValue, "max");
+});
+test("switching model updates thought_level options via config_option_update", async () => {
+    const conn = createConnectionStub();
+    const agent = new GlmAcpAgent(conn, { sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    // Start with glm-5.2 (default) → max, options none/high/max.
+    // Switch to glm-4.7 → thoughtLevel should resolve to "on".
+    await agent.unstable_setSessionModel({ sessionId, modelId: "glm-4.7" });
+    const configUpdates = conn.updates.filter((u) => u.update.sessionUpdate === "config_option_update");
+    assert.equal(configUpdates.length, 1);
+    const opts = configUpdates[0].update.configOptions;
+    const tl = opts.find((o) => o.id === "thought_level");
+    assert.equal(tl.currentValue, "on");
+    const values = tl.options.map((o) => o.value);
+    assert.deepEqual(values, ["none", "on"]);
+});
+test("thoughtLevel is forwarded to streamChat as reasoningEffort", async () => {
+    const conn = createConnectionStub();
+    let seenEffort;
+    const glm = {
+        async *streamChat(_messages, _signal, options) {
+            seenEffort = options?.reasoningEffort;
+            yield { text: "ok" };
+            yield { done: true, stopReason: "stop" };
+        },
+    };
+    const agent = new GlmAcpAgent(conn, { glm, sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    await agent.setSessionConfigOption({ sessionId, configId: "thought_level", value: "high" });
+    await agent.prompt({ sessionId, prompt: [{ type: "text", text: "hi" }] });
+    assert.equal(seenEffort, "high");
+});
+test("thoughtLevel round-trips through fork via persistence", async () => {
+    const dir = mkdtempSync(pathJoin(osTmpdir(), "glm-acp-thoughtlevel-"));
+    try {
+        const store = new SessionStore(dir);
+        const conn = createConnectionStub();
+        const agent = new GlmAcpAgent(conn, { sessionStore: store });
+        await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+        const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+        await agent.setSessionConfigOption({ sessionId, configId: "thought_level", value: "high" });
+        const forked = await agent.unstable_forkSession({ sessionId, cwd: "/tmp", mcpServers: [] });
+        const tl = forked.configOptions.find((o) => o.id === "thought_level");
+        assert.equal(tl.currentValue, "high");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("model switch persists model + clamped thoughtLevel before any prompt (fork sees it)", async () => {
+    const dir = mkdtempSync(pathJoin(osTmpdir(), "glm-acp-switch-"));
+    try {
+        const store = new SessionStore(dir);
+        const conn = createConnectionStub();
+        const agent = new GlmAcpAgent(conn, { sessionStore: store });
+        await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+        const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+        // Switch model with no prompt in between: glm-5.2/max → glm-4.7, which
+        // clamps the level to "on". Both must survive a fork that reads from disk.
+        await agent.unstable_setSessionModel({ sessionId, modelId: "glm-4.7" });
+        const forked = await agent.unstable_forkSession({ sessionId, cwd: "/tmp", mcpServers: [] });
+        assert.equal(forked.models.currentModelId, "glm-4.7");
+        const tl = forked.configOptions.find((o) => o.id === "thought_level");
+        assert.equal(tl.currentValue, "on");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("v2 sessions (no thoughtLevel) migrate and resolve to the model default on load", async () => {
+    const dir = mkdtempSync(pathJoin(osTmpdir(), "glm-acp-migrate-"));
+    const sessionId = "abcd1234-abcd-abcd-abcd-abcdabcd1234";
+    try {
+        // Write a raw v2 record: has `mode` but no `thoughtLevel`.
+        const v2 = {
+            schemaVersion: 2,
+            sessionId,
+            cwd: "/tmp",
+            messages: [{ role: "system", content: "you are a coding assistant" }],
+            title: "old session",
+            updatedAt: "2026-01-01T00:00:00.000Z",
+            model: "glm-5.1",
+            mode: "default",
+        };
+        writeFileSync(pathJoin(dir, `${sessionId}.json`), JSON.stringify(v2), "utf8");
+        // The store migrates the raw record, defaulting thoughtLevel to "max".
+        const store = new SessionStore(dir);
+        const migrated = store.load(sessionId);
+        assert.equal(migrated?.schemaVersion, 3);
+        assert.equal(migrated?.thoughtLevel, "max");
+        // On load the agent clamps that to the session's model (glm-5.1 → "on").
+        const conn = createConnectionStub();
+        const agent = new GlmAcpAgent(conn, { sessionStore: store });
+        await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+        const result = await agent.loadSession({ sessionId, cwd: "/tmp", mcpServers: [] });
+        const tl = result.configOptions.find((o) => o.id === "thought_level");
+        assert.equal(tl.currentValue, "on");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
 });
 // ---------------------------------------------------------------------------
 // Prompt loop
@@ -1028,6 +1231,100 @@ test("prompt with image block runs Vision MCP preprocessing and feeds text into
     assert.match(capturedUser, /What is in this image\?/);
     assert.match(capturedUser, /<image_analysis index="1">[\s\S]*It is a kitten\.[\s\S]*<\/image_analysis>/);
 });
+test("prompt with image block on vision-native model sends native image_url content", async () => {
+    const conn = createConnectionStub();
+    let capturedUser;
+    const glm = {
+        async *streamChat(messages, _signal, options) {
+            assert.equal(options?.model, "glm-5v-turbo");
+            const userMsg = [...messages].reverse().find((m) => m.role === "user");
+            capturedUser = userMsg?.content;
+            yield { text: "ok" };
+            yield { done: true, stopReason: "stop" };
+        },
+    };
+    const visionCalls = [];
+    const visionClient = {
+        async callTool(_name, args) {
+            visionCalls.push(args);
+            return { content: [{ type: "text", text: "should not be used" }] };
+        },
+        async dispose() { },
+    };
+    const agent = new GlmAcpAgent(conn, { glm, visionClient, sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    await agent.unstable_setSessionModel({ sessionId, modelId: "glm-5v-turbo" });
+    await agent.prompt({
+        sessionId,
+        prompt: [
+            { type: "text", text: "What is in this image?" },
+            { type: "image", data: "", mimeType: "image/png", uri: "https://example.com/cat.png" },
+        ],
+    });
+    assert.equal(visionCalls.length, 0);
+    assert.deepEqual(capturedUser, [
+        { type: "text", text: "What is in this image?" },
+        { type: "image_url", image_url: { url: "https://example.com/cat.png" } },
+    ]);
+});
+test("prompt with inline image data on vision-native model sends a data URI", async () => {
+    const conn = createConnectionStub();
+    let capturedUser;
+    const glm = {
+        async *streamChat(messages) {
+            const userMsg = [...messages].reverse().find((m) => m.role === "user");
+            capturedUser = userMsg?.content;
+            yield { text: "ok" };
+            yield { done: true, stopReason: "stop" };
+        },
+    };
+    const agent = new GlmAcpAgent(conn, { glm, visionClient: null, sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    await agent.unstable_setSessionModel({ sessionId, modelId: "glm-5v-turbo" });
+    await agent.prompt({
+        sessionId,
+        prompt: [
+            { type: "text", text: "Describe" },
+            { type: "image", data: "AAAA", mimeType: "image/jpeg" },
+        ],
+    });
+    assert.deepEqual(capturedUser, [
+        { type: "text", text: "Describe" },
+        { type: "image_url", image_url: { url: "data:image/jpeg;base64,AAAA" } },
+    ]);
+});
+test("prompt with unsupported image MIME on vision-native model emits an inline annotation", async () => {
+    const conn = createConnectionStub();
+    let capturedUser;
+    const glm = {
+        async *streamChat(messages) {
+            const userMsg = [...messages].reverse().find((m) => m.role === "user");
+            capturedUser = userMsg?.content;
+            yield { text: "ok" };
+            yield { done: true, stopReason: "stop" };
+        },
+    };
+    const agent = new GlmAcpAgent(conn, { glm, visionClient: null, sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    await agent.unstable_setSessionModel({ sessionId, modelId: "glm-5v-turbo" });
+    await agent.prompt({
+        sessionId,
+        prompt: [
+            { type: "text", text: "Describe" },
+            { type: "image", data: "AAAA", mimeType: "image/webp" },
+        ],
+    });
+    assert.ok(Array.isArray(capturedUser));
+    const text = capturedUser
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n");
+    assert.match(text, /<image_unsupported_format index="1" mime="image\/webp">/);
+    assert.match(text, /image\/jpeg, image\/jpg, image\/png/);
+});
 test("prompt with image block but no vision client falls back to a text annotation", async () => {
     const conn = createConnectionStub();
     let capturedUser;
@@ -1152,6 +1449,7 @@ test("loadSession restores messages and replays them as session updates", async
             title: "ping pong",
             updatedAt: "2026-01-01T00:00:00.000Z",
             model: "glm-5.1",
+            mode: "default",
         });
         const conn = createConnectionStub();
         const agent = new GlmAcpAgent(conn, { sessionStore: store });
@@ -1213,6 +1511,7 @@ test("resumeSession restores in-memory state without replaying messages", async
             title: "ping pong",
             updatedAt: "2026-01-01T00:00:00.000Z",
             model: "glm-5.1",
+            mode: "default",
         });
         const conn = createConnectionStub();
         const agent = new GlmAcpAgent(conn, { sessionStore: store });
@@ -1270,6 +1569,7 @@ test("unstable_forkSession works on a session that exists only on disk", async (
             title: "origin",
             updatedAt: "2026-01-01T00:00:00.000Z",
             model: "glm-4.5",
+            mode: "default",
         });
         const conn = createConnectionStub();
         const agent = new GlmAcpAgent(conn, { sessionStore: store });
@@ -1311,6 +1611,7 @@ test("listSessions surfaces persisted-but-not-in-memory sessions", async () => {
             title: "Saved earlier",
             updatedAt: "2026-01-01T00:00:00.000Z",
             model: "glm-5.1",
+            mode: "default",
         });
         const conn = createConnectionStub();
         const agent = new GlmAcpAgent(conn, { sessionStore: store });
@@ -1323,4 +1624,94 @@ test("listSessions surfaces persisted-but-not-in-memory sessions", async () => {
         cleanup();
     }
 });
+test("prompt performs emergency compaction and retries on 1261 error", async () => {
+    const conn = createConnectionStub();
+    let callCount = 0;
+    let messagesInSecondCall = 0;
+    const glm = {
+        async *streamChat(messages) {
+            callCount++;
+            if (callCount === 1) {
+                // Simulate a Z.AI context overflow error (1261).
+                const err = new Error("Prompt exceeds max length");
+                err.error = { code: 1261 };
+                throw err;
+            }
+            else {
+                messagesInSecondCall = messages.length;
+                yield { text: "Recovered." };
+                yield { done: true, stopReason: "stop" };
+            }
+        },
+    };
+    const agent = new GlmAcpAgent(conn, { glm, sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    // Seed the session with a bunch of messages to be compacted. Pin the session
+    // to a 128K-window model so the seeded history triggers the proactive/
+    // emergency compaction paths (the default model now has a 1M window).
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    await agent.unstable_setSessionModel({ sessionId, modelId: "glm-5.1" });
+    const session = agent.sessions.get(sessionId);
+    assert.ok(session, "expected in-memory session to exist");
+    for (let i = 0; i < 50; i++) {
+        session.messages.push({ role: "user", content: "Very long message filler ".repeat(1000) });
+        session.messages.push({ role: "assistant", content: "Intermediate response filler ".repeat(1000) });
+    }
+    const messagesBefore = session.messages.length;
+    const result = await agent.prompt({
+        sessionId,
+        prompt: [{ type: "text", text: "Final trigger" }],
+    });
+    assert.equal(result.stopReason, "end_turn");
+    assert.equal(callCount, 2, "expected two streamChat calls (one failed, one retried)");
+    assert.ok(messagesInSecondCall < messagesBefore, "expected history to be compacted in the second call");
+    // The system prompt (index 0) and the last 10 messages should be preserved.
+    assert.ok(messagesInSecondCall >= 11);
+});
+test("prompt fails fast when context overflow persists after emergency compaction", async () => {
+    const conn = createConnectionStub();
+    let callCount = 0;
+    let secondOverflow = null;
+    const glm = {
+        async *streamChat() {
+            callCount++;
+            if (callCount > 2) {
+                throw new Error("streamChat retried more than once");
+            }
+            // Simulate a persistent Z.AI context overflow error (1261).
+            const err = new Error("Prompt still exceeds max length after compaction");
+            err.error = { code: 1261 };
+            if (callCount === 2) {
+                secondOverflow = err;
+            }
+            yield await Promise.reject(err);
+        },
+    };
+    const agent = new GlmAcpAgent(conn, { glm, sessionStore: null });
+    await agent.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+    const { sessionId } = await agent.newSession({ cwd: "/tmp", mcpServers: [] });
+    // Use a try-catch to assert that prompt surfaces the error rather than retrying forever.
+    // The agent.prompt method catches internal errors and emits them as agent messages, 
+    // so we check the updates emitted to the connection.
+    let caught;
+    try {
+        await agent.prompt({
+            sessionId,
+            prompt: [{ type: "text", text: "Trigger overflow" }],
+        });
+    }
+    catch (error) {
+        caught = error;
+    }
+    const errorMessages = conn.updates.filter((u) => {
+        const update = u.update;
+        return (update?.sessionUpdate === "agent_message_chunk" &&
+            update.content?.text?.includes("Context overflow persisted"));
+    });
+    assert.equal(callCount, 2, "expected exactly two calls: initial and one retry after compaction");
+    assert.ok(caught instanceof Error);
+    assert.equal(caught.message, "Context overflow persisted after emergency compaction");
+    assert.equal(caught.cause, secondOverflow);
+    assert.equal(errorMessages.length, 1, "expected an error message reporting persistent overflow");
+});
 //# sourceMappingURL=agent.test.js.map