wtagent 0.1.0 → 0.2.0

package/src/cli/render-events.js

@@ -54,8 +54,9 @@ function summarizeArgs(name, args = {}) {
 }
 
 export class Renderer {
-  constructor({ stream = process.stdout } = {}) {
+  constructor({ stream = process.stdout, providerLabel = "model" } = {}) {
     this.stream = stream;
+    this.providerLabel = providerLabel;
     this.isTTY = Boolean(stream.isTTY);
     this.spinner = null;
     this.timer = null;
@@ -263,10 +264,10 @@ export class Renderer {
         break;
       case "browser.auth_required":
         this.stopSpinner();
-        this.println(`${YELLOW}Log in to ChatGPT in the opened Chrome window…${RESET}`);
+        this.println(`${YELLOW}Log in to ${this.providerLabel} in the opened Chrome window…${RESET}`);
         break;
       case "browser.authenticated":
-        this.println(`${GREEN}ChatGPT login detected.${RESET}`);
+        this.println(`${GREEN}${this.providerLabel} login detected.${RESET}`);
         break;
       case "conversation.mode_selected": {
         const { requested, status, selectedLabel } = payload;
@@ -304,16 +305,17 @@ export class Renderer {
         this.stopSpinner();
         this.note(
           payload.deadRequest
-            ? `no reply from ChatGPT; asking it to continue (${payload.retry}/${payload.maxRetries})`
-            : `empty ChatGPT response; asking it to continue (${payload.retry}/${payload.maxRetries})`,
+            ? `no reply from ${this.providerLabel}; asking it to continue (${payload.retry}/${payload.maxRetries})`
+            : payload.generationFailed
+              ? `${this.providerLabel} generation failed (server error); asking it to retry (${payload.retry}/${payload.maxRetries})`
+              : `empty ${this.providerLabel} response; asking it to continue (${payload.retry}/${payload.maxRetries})`,
         );
         break;
       case "model.limit_reached":
         this.stopSpinner();
         this.note(
-          "ChatGPT usage limit reached. Try a different thinking level on resume "
-            + "(wtagent resume <session-id> --mode Pro or --mode Current), wait "
-            + "for the limit to reset, or change plans.",
+          `${this.providerLabel} usage limit reached. Wait for the limit to reset, `
+            + "try a different mode on resume, or change plans.",
         );
         break;
       case "model.progress":
@@ -325,6 +327,10 @@ export class Renderer {
       case "protocol.invalid":
         this.note(`format retry${payload.count ? ` (${payload.count})` : ""}: ${truncate(payload.message, 100)}`);
         break;
+      case "protocol.plain_answer":
+        this.stopSpinner();
+        this.note("The model answered without the XML protocol; showing the reply as the final answer.");
+        break;
       case "tool.proposed":
         this.stopSpinner();
         this.#toolCall(payload.name, payload.args);

package/src/cli/self-update.js

@@ -0,0 +1,145 @@
+import { spawn } from "node:child_process";
+import { resolveLaunchPlan } from "../platform/command-launcher.js";
+import { fetchJson, NETWORK_TIMEOUT_MS } from "../shared/fetch-json.js";
+import { getPackageName, getPackageVersion } from "../shared/package-info.js";
+
+export const UPDATE_CHECK_TIMEOUT_MS = NETWORK_TIMEOUT_MS;
+export const UPDATE_COMMAND_TIMEOUT_MS = 10_000;
+export const INSTALL_TIMEOUT_MS = 120_000;
+export const MANUAL_INSTALL_COMMAND = "npm install -g wtagent@latest";
+
+const VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+
+export function npmRegistryLatestUrl(name = getPackageName()) {
+  return `https://registry.npmjs.org/${encodeURIComponent(name)}/latest`;
+}
+
+export function parseVersion(value) {
+  const match = String(value ?? "").trim().match(VERSION_RE);
+  if (!match) {
+    return null;
+  }
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    pre: match[4] ?? null,
+  };
+}
+
+export function compareVersions(left, right) {
+  const parsedLeft = parseVersion(left);
+  const parsedRight = parseVersion(right);
+  if (!parsedLeft || !parsedRight) {
+    return null;
+  }
+  for (let index = 0; index < 3; index += 1) {
+    if (parsedLeft.core[index] !== parsedRight.core[index]) {
+      return parsedLeft.core[index] < parsedRight.core[index] ? -1 : 1;
+    }
+  }
+  if (!parsedLeft.pre && !parsedRight.pre) {
+    return 0;
+  }
+  if (!parsedLeft.pre) {
+    return 1;
+  }
+  if (!parsedRight.pre) {
+    return -1;
+  }
+  if (parsedLeft.pre === parsedRight.pre) {
+    return 0;
+  }
+  return parsedLeft.pre < parsedRight.pre ? -1 : 1;
+}
+
+export function isRemoteNewer(remote, local = getPackageVersion()) {
+  const comparison = compareVersions(local, remote);
+  return comparison != null && comparison < 0;
+}
+
+export async function fetchLatestVersion({
+  fetchImpl,
+  timeoutMs = UPDATE_CHECK_TIMEOUT_MS,
+  packageName = getPackageName(),
+} = {}) {
+  const document = await fetchJson(npmRegistryLatestUrl(packageName), {
+    fetchImpl,
+    timeoutMs,
+  });
+  return typeof document?.version === "string" && document.version.trim()
+    ? document.version.trim()
+    : null;
+}
+
+export async function installLatest({
+  spawnImpl = spawn,
+  planCommandImpl = (program, argv) => resolveLaunchPlan({ program, argv }),
+  timeoutMs = INSTALL_TIMEOUT_MS,
+  stdio = "inherit",
+} = {}) {
+  const plan = planCommandImpl("npm", ["install", "-g", "wtagent@latest"]);
+  return await new Promise((resolve) => {
+    let settled = false;
+    let timer;
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+
+    let child;
+    try {
+      child = spawnImpl(plan.command, plan.args, {
+        stdio,
+        shell: plan.shell,
+        windowsVerbatimArguments: plan.windowsVerbatimArguments,
+      });
+    } catch (error) {
+      finish({ ok: false, error });
+      return;
+    }
+
+    timer = setTimeout(() => {
+      child.kill();
+      finish({ ok: false, error: new Error("npm install timed out.") });
+    }, timeoutMs);
+
+    child.once("error", (error) => {
+      finish({ ok: false, error });
+    });
+    child.once("exit", (code) => {
+      finish({ ok: code === 0, code });
+    });
+  });
+}
+
+export async function runSelfUpdate({
+  fetchLatest = fetchLatestVersion,
+  install = installLatest,
+  write = console.log,
+  writeError = console.error,
+  currentVersion = getPackageVersion(),
+} = {}) {
+  const latest = await fetchLatest({ timeoutMs: UPDATE_COMMAND_TIMEOUT_MS });
+  if (!latest) {
+    writeError("Could not check npm for the latest WTAgent version.");
+    writeError(`Install it manually: ${MANUAL_INSTALL_COMMAND}`);
+    return { status: "error" };
+  }
+  if (!isRemoteNewer(latest, currentVersion)) {
+    write(`Already up to date (${currentVersion}).`);
+    return { status: "current", currentVersion, latest };
+  }
+
+  write(`Updating WTAgent ${currentVersion} → ${latest} ...`);
+  const result = await install();
+  if (!result.ok) {
+    writeError("Update failed.");
+    writeError(`Install it manually: ${MANUAL_INSTALL_COMMAND}`);
+    return { status: "error", currentVersion, latest };
+  }
+  write(`Updated to ${latest}. Run wtagent again to use the new version.`);
+  return { status: "updated", currentVersion, latest };
+}

package/src/cli/startup-notices.js

@@ -0,0 +1,161 @@
+import { fetchJson, NETWORK_TIMEOUT_MS } from "../shared/fetch-json.js";
+import { getPackageVersion } from "../shared/package-info.js";
+import { NoticeStore, getNoticeStorePath } from "./notice-store.js";
+import {
+  MANUAL_INSTALL_COMMAND,
+  fetchLatestVersion,
+  installLatest,
+  isRemoteNewer,
+} from "./self-update.js";
+
+export const NOTICES_URL =
+  "https://raw.githubusercontent.com/XiXian42/wtagent/main/notices.json";
+export const NOTICE_TIMEOUT_MS = NETWORK_TIMEOUT_MS;
+const MAX_NOTICE_TEXT = 2_000;
+const MAX_NOTICE_ID = 128;
+
+const CYAN = "\x1b[36m";
+const RESET = "\x1b[0m";
+
+export function sanitizeNoticeText(value) {
+  return String(value ?? "")
+    .replace(/\r\n|\r/g, "\n")
+    .replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "")
+    .replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)?/g, "")
+    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, "")
+    .trim()
+    .slice(0, MAX_NOTICE_TEXT);
+}
+
+function normalizeTimes(value) {
+  if (value == null) {
+    return 1;
+  }
+  const times = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(times)) {
+    return 1;
+  }
+  return Math.max(0, Math.floor(times));
+}
+
+export function parseNoticeDocument(document) {
+  const raw = Array.isArray(document?.notices) ? document.notices : [];
+  const notices = [];
+  const seen = new Set();
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const id = typeof entry.id === "string" ? entry.id.trim() : "";
+    const text = sanitizeNoticeText(entry.text);
+    if (!id || id.length > MAX_NOTICE_ID || !text || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    notices.push({
+      id,
+      text,
+      times: normalizeTimes(entry.times),
+    });
+  }
+  return notices;
+}
+
+export function selectNotice(notices, store) {
+  for (const notice of notices) {
+    if (notice.times <= 0) {
+      continue;
+    }
+    if (store.shownCount(notice.id) >= notice.times) {
+      continue;
+    }
+    return notice;
+  }
+  return null;
+}
+
+export function formatNotice(text) {
+  return `\n${CYAN}Notice${RESET}\n${text}\n`;
+}
+
+export async function fetchNoticeDocument({
+  fetchImpl,
+  timeoutMs = NOTICE_TIMEOUT_MS,
+  url = NOTICES_URL,
+} = {}) {
+  const document = await fetchJson(url, { fetchImpl, timeoutMs });
+  return document && typeof document === "object" ? document : null;
+}
+
+export async function runStartupChecks({
+  appDataDir,
+  interactive = true,
+  fetchLatest = fetchLatestVersion,
+  fetchNotices = fetchNoticeDocument,
+  install = installLatest,
+  promptUpdate,
+  write = (text) => {
+    console.log(text);
+  },
+  writeError = (text) => {
+    console.error(text);
+  },
+  now,
+} = {}) {
+  if (!interactive) {
+    return "continue";
+  }
+
+  const store = new NoticeStore({
+    filePath: getNoticeStorePath(appDataDir),
+    now,
+  });
+  await store.ensureLoaded();
+
+  const needUpdateCheck = !store.wasUpdatePromptedToday();
+  const needNotice = !store.wasNoticeShownToday();
+  const latestPromise = needUpdateCheck
+    ? fetchLatest({ timeoutMs: NOTICE_TIMEOUT_MS })
+    : Promise.resolve(null);
+  const noticesPromise = needNotice
+    ? fetchNotices({ timeoutMs: NOTICE_TIMEOUT_MS })
+    : Promise.resolve(null);
+
+  const currentVersion = getPackageVersion();
+  const latest = await latestPromise;
+  if (needUpdateCheck && latest) {
+    if (isRemoteNewer(latest, currentVersion)) {
+      write(`A newer WTAgent is available: ${currentVersion} → ${latest}`);
+      const choice = await promptUpdate({ currentVersion, latest });
+      if (choice == null) {
+        return "aborted";
+      }
+      await store.markUpdatePrompted();
+      if (choice) {
+        write(`Updating WTAgent ${currentVersion} → ${latest} ...`);
+        const result = await install();
+        if (result.ok) {
+          write(`Updated to ${latest}. Restart wtagent to use the new version.`);
+          return "updated";
+        }
+        writeError("Update failed.");
+        writeError(`Install it manually: ${MANUAL_INSTALL_COMMAND}`);
+      }
+    } else {
+      await store.markUpdatePrompted();
+    }
+  }
+
+  if (!needNotice) {
+    return "continue";
+  }
+
+  const notices = parseNoticeDocument(await noticesPromise);
+  const selected = selectNotice(notices, store);
+  if (!selected) {
+    return "continue";
+  }
+  write(formatNotice(selected.text).trimEnd());
+  await store.recordNoticeShown(selected.id);
+  return "continue";
+}

package/src/platform/paths.js

@@ -63,6 +63,13 @@ export function getChromeProfileDir(appDataDir = getAppDataDir()) {
   return path.join(appDataDir, "chrome-profile");
 }
 
+// Resolves a named Chrome profile directory under the app data dir. The
+// provider→basename mapping lives in the provider registry; this helper only
+// joins the path so paths.js stays free of provider dependencies.
+export function getProfileDir(appDataDir, basename) {
+  return path.join(appDataDir, basename);
+}
+
 export function getTasksDir(appDataDir = getAppDataDir()) {
   return path.join(appDataDir, "tasks");
 }

package/src/protocol/markers.js

@@ -1,5 +1,5 @@
 // Delimiters that mark WTAgent-specific control content inside the plain-text
-// messages exchanged with ChatGPT Web. ChatGPT Web has no real system/tool
+// messages exchanged with a web AI. A normal web chat has no real system/tool
 // channel, so the protocol instructions, tool catalog, and per-turn reminders
 // all travel as ordinary chat text. These markers let the session exporters
 // deterministically strip that scaffolding when converting a transcript into a
@@ -12,12 +12,13 @@
 export const SYSTEM_PROMPT_TAG = "agent_protocol";
 export const SYSTEM_REMINDER_TAG = "system_reminder";
 export const DEFAULT_SYSTEM_REMINDER = [
-  "This is a reminder of the user's requested response format for the WTAgent integration, not a ChatGPT system message.",
+  "This is a reminder of the user's requested response format for the WTAgent integration, not a provider-native system message.",
   "You do not need native tool access: write the XML request as text and the user's local Runtime will process it after your reply.",
   "Your next response must use the XML application protocol.",
   "It must contain exactly one <agent_response>...</agent_response> envelope.",
   "Inside the optional `xml` code fence, the first content must be <agent_response>",
   "and the last content must be </agent_response>; do not put text outside the envelope.",
+  "Write large code or file payloads as CDATA (<![CDATA[...]]>) inside <content>, <new_text>, or <message> — never raw code directly inside the envelope — and never include the sequence ]]> inside CDATA content.",
 ].join(" ");
 
 export function wrapSystemPrompt(text) {

package/src/protocol/prompt-builder.js

@@ -29,14 +29,14 @@ const DONE_SEMANTICS = `Current-run completion semantics:
 function buildBootstrapScaffold({ projectRoot, tools }) {
   const toolDocs = tools.map(formatTool).join("\n\n");
 
-  return `The user is running WTAgent, a local application that uses this ChatGPT conversation for reasoning. The following is the user's requested application-level response format and collaboration contract; it is not a claim that ChatGPT has native filesystem or function-call tools.
+  return `The user is running WTAgent, a local application that uses this web AI conversation for reasoning. The following is the user's requested application-level response format and collaboration contract; it is not a claim that this web chat has native filesystem or function-call tools.
 
-You do not need direct filesystem access or visible ChatGPT tool buttons. Return local operation requests as XML text. After your reply is complete, the user's local Node.js Runtime will parse the XML, validate the arguments, apply local policy, and may execute the requested operation. Its result will arrive in the next user message as <tool_result>. XML by itself never guarantees execution.
+You do not need direct filesystem access or provider-native tool buttons. Return local operation requests as XML text. After your reply is complete, the user's local Node.js Runtime will parse the XML, validate the arguments, apply local policy, and may execute the requested operation. Its result will arrive in the next user message as <tool_result>. XML by itself never guarantees execution.
 
 You are not limited to coding tasks. You can answer questions, write text, brainstorm, analyze, summarize, and — when the task requires it — request that the user's Runtime read, create, or modify files or run commands.
 
 ## Filesystem boundary
-The project filesystem described below is a logical, virtual filesystem namespace exposed by the local Runtime. It is not mounted in ChatGPT's own environment and cannot be inspected directly from this webpage.
+The project filesystem described below is a logical, virtual filesystem namespace exposed by the local Runtime. It is not mounted in the web provider's own environment and cannot be inspected directly from this webpage.
 
 Do not inspect /workspace, /mnt/data, or any ambient, cloud, or sandbox filesystem. Those locations are unrelated to the user's project. Request all project reads, listings, writes, edits, and commands only through the XML operations declared below.
 
@@ -98,11 +98,15 @@ The project directory may contain content unrelated to the current task: depende
 }
 
 // Returns the pieces needed by both transports:
-//   web       - the exact text to send to ChatGPT Web (scaffold is wrapped in
+//   web       - the exact text to send to the web AI (scaffold is wrapped in
 //               <agent_protocol> markers, the user task follows outside them)
 //   developer - the transport scaffold, exposed for diagnostics/tests only
 //   user      - the user task, for the canonical user message
-export function buildBootstrapPrompt({ task, projectRoot, tools }) {
+export function buildBootstrapPrompt({
+  task,
+  projectRoot,
+  tools,
+}) {
   const developer = buildBootstrapScaffold({ projectRoot, tools });
   const web = `${wrapSystemPrompt(developer)}\n\n## User task\n${task}`;
   return { web, developer, user: task };

package/src/protocol/xml-protocol.js

@@ -63,26 +63,187 @@ function escapeBareAmpersands(text) {
   return out;
 }
 
+function closeDanglingToolCall(envelope) {
+  const open = (envelope.match(/<tool_call(?:\s|>)/gi) ?? []).length;
+  const close = (envelope.match(/<\/tool_call>/gi) ?? []).length;
+  if (open !== close + 1) {
+    return envelope;
+  }
+  return envelope.replace(
+    /(<\/args>\s*)(<\/agent_response>\s*)$/i,
+    "$1</tool_call>\n$2",
+  );
+}
+
+function wrapBareToolCall(text) {
+  const start = text.search(/<tool_call(?:\s|>)/i);
+  const endTag = "</tool_call>";
+  const end = start < 0 ? -1 : text.indexOf(endTag, start);
+  if (start >= 0 && end >= start) {
+    const toolCall = text.slice(start, end + endTag.length);
+    if (/<args[\s>/]/i.test(toolCall)) {
+      return [
+        "<agent_response>",
+        "  <done>false</done>",
+        "  <message></message>",
+        `  ${toolCall}`,
+        "</agent_response>",
+      ].join("\n");
+    }
+  }
+  return wrapClaudeStyleInvoke(text);
+}
+
+// DeepSeek (and some others) occasionally emit Claude-style tool XML:
+//   <tool_calls><invoke name="fs.read"><parameter name="path">README.md</parameter></invoke></tool_calls>
+// and sometimes annotate parameters with attributes, e.g.
+//   <parameter name="program" string="true">npm</parameter>
+//   <parameter name="argv" string="false">["test"]</parameter>
+// Map a single complete invoke onto our envelope so the turn can proceed
+// instead of hanging or burning a format retry.
+function wrapClaudeStyleInvoke(text) {
+  const invoke = /<invoke\s+name="([A-Za-z0-9_.-]+)"(?:\s[^>]*)?>([\s\S]*?)<\/invoke>/i.exec(text);
+  if (!invoke) {
+    return null;
+  }
+  const name = invoke[1];
+  const body = invoke[2];
+  const args = [];
+  const paramRe = /<parameter\s+name="([A-Za-z0-9_.-]+)"(?:\s[^>]*)?>([\s\S]*?)<\/parameter>/gi;
+  for (const match of body.matchAll(paramRe)) {
+    const key = match[1];
+    const value = String(match[2] ?? "").trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(key)) {
+      return null;
+    }
+    args.push(`<${key}>${value}</${key}>`);
+  }
+  if (args.length === 0) {
+    return null;
+  }
+  return [
+    "<agent_response>",
+    "  <done>false</done>",
+    "  <message></message>",
+    `  <tool_call name="${name}">`,
+    `    <args>${args.join("")}</args>`,
+    "  </tool_call>",
+    "</agent_response>",
+  ].join("\n");
+}
+
 function extractEnvelope(text) {
   const cleaned = stripSingleCodeFence(text);
   const start = cleaned.indexOf("<agent_response");
   const endTag = "</agent_response>";
-  const end = cleaned.lastIndexOf(endTag);
+  const end = start < 0 ? -1 : cleaned.indexOf(endTag, start);
 
-  if (start < 0 || end < 0 || end < start) {
+  if (start < 0 || end < 0) {
+    const wrapped = wrapBareToolCall(cleaned);
+    if (wrapped) {
+      return wrapped;
+    }
     throw new ProtocolError(
       "Response must contain one complete <agent_response> envelope.",
       { details: { raw: cleaned } },
     );
   }
 
-  // ChatGPT Web may prepend a preamble (e.g. "Sure, here is the response:")
-  // or append trailing text / render rich cards around the XML. We only care
-  // about the envelope itself, so surrounding text is stripped instead of
-  // being treated as a protocol violation.
+  // Take the first complete envelope only. Web UIs (especially Kimi) often
+  // render the same reply twice — a code-fence copy plus the visible markdown
+  // — so first-open + last-close would glue two envelopes together and fail
+  // with "Extra text at the end". Trailing chatter after that first envelope
+  // is ignored the same way a preamble before it is.
   return cleaned.slice(start, end + endTag.length);
 }
 
+// Web-UIs render provider chrome into the assistant text: thinking-block
+// headers, code-fence language banners, and code-block action button labels.
+// These tokens are UI noise, never model content, but only when they appear as
+// standalone leading lines — a report may legitimately contain the word "运行"
+// inside its prose, so we only strip complete noise lines at the start.
+const UI_NOISE_TOKENS = new Set([
+  // 中文
+  "思考过程",
+  "正在思考",
+  "思考已完成",
+  "思考完成",
+  "跳过",
+  "复制",
+  "复制代码",
+  "下载",
+  "运行",
+  // English
+  "thinking",
+  "thinking process",
+  "reasoning",
+  "skip",
+  "copy",
+  "copy code",
+  "download",
+  "run",
+  // 日本語
+  "考え中",
+  "検討中",
+  "スキップ",
+  "コピー",
+  "コードをコピー",
+  "ダウンロード",
+  "実行",
+  // 한국어
+  "생각 중",
+  "복사",
+  "코드 복사",
+  "다운로드",
+  "실행",
+  "건너뛰기",
+  // Language banner on rendered code blocks (locale-independent).
+  "xml",
+]);
+
+export function stripUiNoiseLines(text) {
+  const lines = String(text ?? "").split(/\r?\n/).map((line) => line.trim());
+  while (
+    lines.length
+    && (
+      lines[0] === ""
+      || UI_NOISE_TOKENS.has(lines[0])
+      || UI_NOISE_TOKENS.has(lines[0].toLowerCase())
+    )
+  ) {
+    lines.shift();
+  }
+  return lines.join("\n").trim();
+}
+
+// Returns the substantive prose that follows the first complete
+// <agent_response> envelope, or null when there is none.
+//
+// Some models (GLM especially) put their REAL deliverable after the envelope:
+// the XML carries only a short done/true stub and the full answer is rendered
+// as ordinary markdown/HTML text right after it. That text is pure display
+// content — it can never trigger a tool call — so the runtime may surface it
+// as the final answer instead of dropping it.
+//
+// Defensive rule: if the trailing text contains another <agent_response (some
+// UIs render the reply twice, a code-fence copy plus the visible copy), we
+// cannot cleanly separate real content from the duplicated XML, so return null
+// and let the caller keep the envelope's own message.
+export function extractTrailingProse(rawText) {
+  const text = String(rawText ?? "");
+  const endTag = "</agent_response>";
+  const end = text.indexOf(endTag);
+  if (end < 0) {
+    return null;
+  }
+  const trailing = text.slice(end + endTag.length);
+  if (trailing.includes("<agent_response")) {
+    return null;
+  }
+  const withoutFenceCloser = trailing.replace(/\n*```\s*$/, "");
+  return stripUiNoiseLines(withoutFenceCloser) || null;
+}
+
 function normalizeXmlValue(value) {
   if (value == null) {
     return "";
@@ -206,10 +367,13 @@ export function parseAgentResponse(rawText) {
     throw new ProtocolError("DTD and XML entities are not allowed.");
   }
 
-  // Repair the single most common corruption first: bare ampersands the model
-  // wrote outside CDATA. This is done before validation so an otherwise
-  // well-formed envelope with a stray "&" parses instead of triggering a retry.
-  const envelope = escapeBareAmpersands(rawEnvelope);
+  // Repair the most common, meaning-preserving corruptions before validation:
+  // 1. bare ampersands the model wrote outside CDATA
+  // 2. a missing </tool_call> immediately before </agent_response>
+  // GLM in particular often streams a complete <tool_call>…</args> and then
+  // closes the envelope without the matching </tool_call>. Inserting that one
+  // tag is safe: we never invent arguments, only finish an already-complete call.
+  const envelope = closeDanglingToolCall(escapeBareAmpersands(rawEnvelope));
 
   const validation = XMLValidator.validate(envelope);
   if (validation !== true) {
@@ -401,9 +565,27 @@ export function serializeToolResult(result, { maxBytes = Infinity } = {}) {
 }
 
 export function serializeProtocolError(error) {
+  // Structural XML failures need more than the raw parser message. The two
+  // recurring causes: (a) raw code placed directly inside the envelope — bare
+  // < or & outside CDATA is illegal XML (the parser reports things like
+  // "Invalid space after '<'"); (b) a reply cut off before </agent_response>,
+  // so nothing in it was executed. Tell the model exactly how to fix both.
+  const message = String(error?.message ?? "");
+  const structural = /complete <agent_response> envelope|closing tag|invalid xml|space after '<'/i.test(message);
+  const guidance = structural
+    ? cdata(
+      "Wrap ALL code and file content in CDATA (<![CDATA[...]]>) inside "
+        + "<content>, <new_text>, or <message>. Never put raw code directly "
+        + "inside the envelope: XML forbids a bare < or & in text. Split large "
+        + "changes into SMALL fs.edit calls (each new_text at most ~30 lines) "
+        + "and close the envelope with </agent_response> immediately after "
+        + "the last tool_call. Never leave the envelope open.",
+    )
+    : "";
   return [
     "<protocol_error>",
-    cdata(error.message),
+    cdata(message),
+    guidance,
     "</protocol_error>",
   ].join("");
 }