glm-mcp-copilot 1.1.0 → 1.3.0

package/README.md

@@ -12,7 +12,13 @@ calls `glm_agent` / `glm_delegate` / `glm_recommend` / `glm_status` to offload w
   - **`glm_delegate`** — GLM drafts text you place.
   - **`glm_recommend`** — free advisory: GLM vs the default model.
   - **`glm_status`** — usage ledger (proof of GLM tokens spent) + config.
-- A **`.github/copilot-instructions.md`** delegation policy so Copilot offloads to GLM automatically.
+- A **`GLM` custom agent (subagent)** — restricted to the `glm` tools, so it *must* delegate to GLM
+  (the Copilot analog of the Claude `glm` subagent). Pick it from the chat mode dropdown or hand off to it.
+- A **delegation-policy instructions file** so Copilot offloads to GLM automatically.
+- A **PreToolUse auto-routing hook** (`glm_router_hook.mjs`) — fires before the default model does work
+  itself and nudges delegating to GLM (the Copilot analog of the Claude `glm_subagent_router` hook).
+  Installed to `.github/hooks/glm.hooks.json` per-project, or `~/.copilot/hooks/glm.hooks.json` globally.
+  Non-blocking (always allows the tool call). VS Code **preview feature**.
 
 ## Prerequisites
 - **VS Code** with **GitHub Copilot + Copilot Chat**, and **Agent mode** available (MCP support).
@@ -32,7 +38,9 @@ Run it **from your project folder** (it sets up that workspace). It:
 1. installs the GLM MCP server to `~/.glm-mcp/glm-mcp/` and runs `npm install`,
 2. writes your key to that server's `.env`,
 3. registers the server in `.vscode/mcp.json` (VS Code's `servers` format),
-4. writes `.github/copilot-instructions.md` (the delegation policy).
+4. installs the **`GLM` custom agent** → `.github/agents/glm.agent.md`,
+5. writes `.github/copilot-instructions.md` (the delegation policy),
+6. installs the **PreToolUse auto-routing hook** → `.github/hooks/glm.hooks.json`.
 
 ### Global (all projects)
 Set it up once for **every** workspace with `--global`:
@@ -40,22 +48,35 @@ Set it up once for **every** workspace with `--global`:
 npx glm-mcp-copilot --global --key YOUR_ZAI_API_KEY
 ```
 Global mode writes to VS Code's **user config** instead of one workspace:
-- the `glm` server → the **user `mcp.json`** (available in all workspaces), and
-- the delegation policy → **user `settings.json`** (`github.copilot.chat.codeGeneration.instructions`).
+- the `glm` server → the **user `mcp.json`** (all workspaces),
+- the **`GLM` custom agent** → `~/.copilot/agents/glm.agent.md`,
+- the delegation policy → `~/.copilot/instructions/glm.instructions.md` (with `applyTo: '**'`),
+- the **PreToolUse auto-routing hook** → `~/.copilot/hooks/glm.hooks.json`,
+- and it registers those locations + enables agent mode in **user `settings.json`**
+  (`chat.agentFilesLocations`, `chat.instructionsFilesLocations`, `chat.agent.enabled`).
 
-> The global **server** is reliable across VS Code versions. The global **instructions** setting is
-> VS-Code-version-dependent (its exact key is evolving) — if Copilot ignores it in your version, the
-> tools are still there; just nudge it ("use glm_agent to…"), or add a repo `.github/copilot-instructions.md`.
+> Uses the current (non-deprecated) instructions mechanism — `.instructions.md` files, **not** the old
+> `codeGeneration.instructions` settings array (deprecated in VS Code 1.102; the installer migrates off it).
 > Use `--vscode-user-dir PATH` if your VS Code User folder isn't auto-detected (Insiders/VSCodium/portable).
 
 Then in VS Code: **Reload Window → open Copilot Chat → Agent mode → start the `glm` server** (`MCP: List
 Servers`). Ask Copilot to do a coding task; it will call `glm_agent`.
 
 ## How it differs from the Claude Code version
-Copilot doesn't have Claude Code's *subagents* or *PreToolUse hooks*, so there's no auto-routing hook or
-`glm` subagent. Instead:
-- **MCP tools** (`glm_*`) are available in **agent mode** and Copilot calls them.
-- **`.github/copilot-instructions.md`** steers Copilot to delegate to GLM (the CLAUDE.md equivalent).
+**Essentially full parity** — Copilot now has all three primitives:
+- **`glm_*` MCP tools** in **agent mode** (same server as the Claude edition).
+- A **`GLM` custom agent (subagent)** restricted to the `glm` tools — the analog of the Claude `glm`
+  subagent (forced to delegate to GLM). Invoke it from the mode dropdown or via an agent handoff.
+- A **PreToolUse agent hook** (`glm_router_hook.mjs`) that auto-nudges delegation — the analog of the
+  Claude `glm_subagent_router` hook: before the default model does work itself, it suggests delegating
+  to `glm_agent` (non-blocking; it only injects advisory context, never denies a tool call).
+- **Instructions files** steer delegation (the CLAUDE.md equivalent).
+
+Small differences that remain:
+- VS Code hooks **ignore the matcher**, so the hook fires on *every* tool call and filters by
+  `tool_name` internally (and advises at most once per session to stay quiet).
+- VS Code **hooks are a preview feature**; flip them on in Copilot settings if your build hides them.
+- There is **no separate `glm-code` full-GLM launcher** (Claude's standalone all-GLM entry point).
 
 Everything else — the GLM agent loop, peak-aware model pick, cost bias, token cap, usage ledger,
 `dry_run` oversight — is the **same server**, so it behaves identically once a tool is called.

package/glm.agent.md

@@ -0,0 +1,22 @@
+---
+name: GLM
+description: Cheap GLM delegate — offloads coding/edit/refactor/test/docs work to the GLM model (~10x cheaper than the default) via the glm MCP server. Use for well-specified, self-contained tasks; keep sensitive/vision/parallel/huge-context/heavy-tool-loop work on the default model.
+tools: ['glm/*']
+user-invocable: true
+---
+
+You are the **GLM delegate**. You have ONLY the `glm` MCP server's tools — **you cannot edit files or
+run commands yourself**, so you must route all real work through GLM (this keeps the work, and the
+tokens, on GLM — ~10× cheaper than the default model).
+
+## How you work
+1. **Do the work via GLM.** For any coding / edit / refactor / test / docs task, call **`glm/glm_agent`**
+   with the goal + the **absolute repo path** (`workdir`). GLM reads, writes, edits, and runs the files
+   itself, end-to-end. For pure text, use **`glm/glm_delegate`**.
+2. **Check fit when unsure.** Call **`glm/glm_recommend`**; if it says the task should stay on the
+   default model (sensitive, vision, parallel, >128K context, heavy dependent tool-loops), say so and stop.
+3. **Report the GLM stats.** Surface the `=== GLM STATS ===` block `glm_agent` returns (model + tokens
+   delegated + cost) so it's clear GLM did the work and how much it spent. Run **`glm/glm_status`** for
+   the cumulative usage ledger.
+
+Never claim to have done work you didn't route through GLM — you have no other tools.

package/glm.instructions.md

@@ -0,0 +1,18 @@
+---
+applyTo: '**'
+---
+
+# GLM delegation
+
+The **glm** MCP server is available in agent mode (`glm_agent`, `glm_delegate`, `glm_recommend`,
+`glm_status`). GLM (Zhipu/Z.ai) is **~10× cheaper** than the default model — offload work to it.
+
+- For any implementation / codegen / edit / refactor / test / docs task, call **`glm_agent`** with the
+  goal + the absolute repo path (`workdir`) so GLM does it end-to-end on **GLM tokens** — or hand it to
+  the **GLM** custom agent (subagent). Prefer this over doing the file work yourself.
+- Use **`glm_delegate`** for pure text.
+- **To actually spend GLM tokens (not the default model's), call the glm tools — don't do the work
+  inline yourself.**
+- Keep on the default model: sensitive/secret code, vision/images, parallel work, very large context
+  (>128K), and heavy dependent tool-loops. Unsure? call **`glm_recommend`**.
+- `glm_status` shows the GLM usage ledger — proof of GLM tokens spent.

package/glm_router_hook.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// glm_router_hook.mjs — PreToolUse hook for GitHub Copilot (VS Code agent hooks).
+// The Copilot analog of the Claude Code glm_subagent_router hook: before the default
+// model does work itself, it nudges delegating to GLM (glm_agent, ~10x cheaper).
+// Non-blocking — it only injects advisory context, never denies a tool call.
+import { readFileSync, existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+let raw = "";
+try { raw = readFileSync(0, "utf8"); } catch {}
+let data = {};
+try { data = JSON.parse(raw || "{}"); } catch {}
+
+const tool = String(data.tool_name || "");
+const sessionId = String(data.session_id || "");
+
+// "Copilot is about to do real work itself" (not via GLM).
+const WORK_TOOLS = new Set([
+  "editFiles", "createFile", "deleteFile", "applyPatch",
+  "runTerminalCommand", "runCommands", "runInTerminal",
+]);
+
+const allow = (extra) =>
+  process.stdout.write(JSON.stringify({ continue: true, hookSpecificOutput: { permissionDecision: "allow", ...(extra || {}) }, ...(extra && extra.systemMessage ? { systemMessage: extra.systemMessage } : {}) }));
+
+// Never interfere with GLM's own tools, reads, or anything that isn't direct work.
+if (!WORK_TOOLS.has(tool) || /glm/i.test(tool)) { allow(); process.exit(0); }
+
+// Advise only ONCE per session to avoid noise on every edit.
+const marker = join(tmpdir(), "glm-router-" + (sessionId || "nosess") + ".flag");
+if (sessionId && existsSync(marker)) { allow(); process.exit(0); }
+try { if (sessionId) writeFileSync(marker, "1"); } catch {}
+
+const context =
+  "GLM router: the default model is about to do this work itself. If this is a well-specified, " +
+  "self-contained coding / edit / refactor / test / docs task, delegate it to GLM instead — call " +
+  "glm_agent with the goal + the absolute repo path (workdir) so it runs on GLM tokens (~10x cheaper), " +
+  "then review the result. Keep sensitive/secret, vision, parallel, very-large-context (>128K), and " +
+  "heavy dependent tool-loop work on the default model. Run glm_recommend if unsure.";
+
+process.stdout.write(JSON.stringify({
+  continue: true,
+  systemMessage: "GLM router: consider delegating this to glm_agent (~10x cheaper).",
+  hookSpecificOutput: { permissionDecision: "allow", additionalContext: context },
+}));
+process.exit(0);

package/install-copilot.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 // install-copilot.mjs — set up GLM as a delegate for GitHub Copilot / Copilot Chat (VS Code agent mode).
 // Installs the shared GLM MCP server, registers it in the workspace .vscode/mcp.json (VS Code's
-// "servers" format), and writes .github/copilot-instructions.md so Copilot delegates to GLM.
-// It does NOT touch any Claude Code setup.
+// "servers" format), writes .github/copilot-instructions.md so Copilot delegates to GLM, and installs a
+// PreToolUse agent hook (.github/hooks/glm.hooks.json or ~/.copilot/hooks/glm.hooks.json) that nudges
+// delegation to GLM. It does NOT touch any Claude Code setup.
 //
 // Usage:
 //   node install-copilot.mjs --key YOUR_ZAI_KEY          # set up in the current workspace
@@ -63,6 +64,13 @@ cpSync(join(SELF, "glm-mcp"), join(SERVER_HOME, "glm-mcp"), {
   },
 });
 
+// Also stage the PreToolUse hook script inside the server home so the hook has a stable absolute path.
+step("Staging the GLM PreToolUse hook script");
+copyFileSync(join(SELF, "glm_router_hook.mjs"), join(SERVER_HOME, "glm_router_hook.mjs"));
+const hookScript = join(SERVER_HOME, "glm_router_hook.mjs").replace(/\\/g, "/");
+const hookCmd = 'node "' + hookScript + '"';
+log("  " + join(SERVER_HOME, "glm_router_hook.mjs"));
+
 // 2. .env (API key)
 step("Setting up .env");
 const envPath = join(SERVER_HOME, "glm-mcp", ".env");
@@ -82,8 +90,12 @@ if (!SKIP_NPM) {
   execSync("npm install --no-audit --no-fund", { cwd: join(SERVER_HOME, "glm-mcp"), stdio: "inherit" });
 }
 
-// 4 & 5. Register the server + delegation policy — globally (all workspaces) or in this workspace.
+// 4-6. Register the server, the `glm` custom agent (subagent), and the delegation policy —
+// globally (all workspaces) or in this workspace.
 const idx = join(SERVER_HOME, "glm-mcp", "src", "index.js").replace(/\\/g, "/");
+const AGENTS_HOME = join(homedir(), ".copilot", "agents"); // global custom-agent location
+const INSTR_HOME = join(homedir(), ".copilot", "instructions"); // global instructions location
+const HOOKS_HOME = join(homedir(), ".copilot", "hooks"); // global hooks location
 
 function mergeMcp(mcpPath) {
   mkdirSync(dirname(mcpPath), { recursive: true });
@@ -97,61 +109,85 @@ function mergeMcp(mcpPath) {
   writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + "\n");
   return mcpPath;
 }
-
-const CONCISE_POLICY =
-  "GLM delegation: prefer the glm MCP tools. For any coding / edit / refactor / test / docs task, call " +
-  "glm_agent with the goal + the absolute repo path (workdir) so GLM does it end-to-end on GLM tokens " +
-  "(~10x cheaper) — don't do the file work yourself when GLM can. Use glm_delegate for pure text. Keep " +
-  "sensitive/secret code, vision, parallel work, >128K context, and heavy dependent tool-loops on the " +
-  "default model. Run glm_status for the GLM usage ledger.";
+function copyInto(dir, srcFile) {
+  mkdirSync(dir, { recursive: true });
+  const dest = join(dir, srcFile);
+  copyFileSync(join(SELF, srcFile), dest);
+  return dest;
+}
+function writeHookFile(dir) {
+  mkdirSync(dir, { recursive: true });
+  const p = join(dir, "glm.hooks.json");
+  writeFileSync(p, JSON.stringify({ hooks: { PreToolUse: [ { type: "command", command: hookCmd, timeout: 10 } ] } }, null, 2) + "\n");
+  return p;
+}
 
 if (GLOBAL) {
   const userDir = vscodeUserDir();
   step("Registering glm GLOBALLY (VS Code user mcp.json) -> " + userDir);
   log("  " + mergeMcp(join(userDir, "mcp.json")));
 
-  step("Adding GLOBAL Copilot instructions (VS Code user settings.json)");
+  step("Installing the GLM custom agent (subagent) -> " + AGENTS_HOME);
+  log("  " + copyInto(AGENTS_HOME, "glm.agent.md"));
+
+  step("Installing GLOBAL Copilot instructions -> " + INSTR_HOME);
+  log("  " + copyInto(INSTR_HOME, "glm.instructions.md"));
+
+  step("Installing the GLM PreToolUse hook (auto-routing) -> " + HOOKS_HOME);
+  log("  " + writeHookFile(HOOKS_HOME));
+
+  step("Updating VS Code user settings.json (locations + toggles)");
   const setPath = join(userDir, "settings.json");
   let settings = {};
   if (existsSync(setPath)) {
     try { settings = JSON.parse(readFileSync(setPath, "utf8")); } catch { settings = {}; }
     writeFileSync(setPath + ".bak-" + Date.now(), readFileSync(setPath));
   }
-  const K = "github.copilot.chat.codeGeneration.instructions";
-  const arr = Array.isArray(settings[K]) ? settings[K] : [];
-  if (!arr.some((e) => e && typeof e.text === "string" && e.text.includes("glm_agent"))) {
-    arr.push({ text: CONCISE_POLICY });
-    settings[K] = arr;
-    writeFileSync(setPath, JSON.stringify(settings, null, 2) + "\n");
-    log("  added to " + setPath);
-  } else {
-    log("  policy already present");
+  const agentsGlob = AGENTS_HOME.replace(/\\/g, "/");
+  const instrGlob = INSTR_HOME.replace(/\\/g, "/");
+  settings["chat.agentFilesLocations"] = { ...(settings["chat.agentFilesLocations"] || {}), [agentsGlob]: true };
+  settings["chat.instructionsFilesLocations"] = { ...(settings["chat.instructionsFilesLocations"] || {}), [instrGlob]: true };
+  settings["github.copilot.chat.codeGeneration.useInstructionFiles"] = true;
+  settings["chat.agent.enabled"] = true;
+  // Migrate off the deprecated inline-instructions setting (remove our old entry if present).
+  const DEP = "github.copilot.chat.codeGeneration.instructions";
+  if (Array.isArray(settings[DEP])) {
+    settings[DEP] = settings[DEP].filter((e) => !(e && typeof e.text === "string" && e.text.includes("glm_agent")));
+    if (settings[DEP].length === 0) delete settings[DEP];
   }
+  writeFileSync(setPath, JSON.stringify(settings, null, 2) + "\n");
+  log("  " + setPath);
 } else {
   step("Registering the glm server in VS Code (workspace .vscode/mcp.json)");
   log("  " + mergeMcp(join(WORKSPACE, ".vscode", "mcp.json")));
 
+  step("Installing the GLM custom agent (subagent) -> .github/agents/");
+  log("  " + copyInto(join(WORKSPACE, ".github", "agents"), "glm.agent.md"));
+
   step("Adding delegation policy (workspace .github/copilot-instructions.md)");
-  const ghDir = join(WORKSPACE, ".github");
-  mkdirSync(ghDir, { recursive: true });
-  const ciPath = join(ghDir, "copilot-instructions.md");
+  const ciPath = join(WORKSPACE, ".github", "copilot-instructions.md");
+  mkdirSync(dirname(ciPath), { recursive: true });
   const policy = readFileSync(join(SELF, "copilot-instructions.md"), "utf8");
   const existing = existsSync(ciPath) ? readFileSync(ciPath, "utf8") : "";
   if (!existing.includes("glm_agent")) {
     writeFileSync(ciPath, existing + (existing ? "\n\n" : "") + policy);
     log("  " + ciPath);
   } else {
-    log("  policy already present (left as-is)");
+    log("  copilot-instructions.md already has the policy");
   }
+
+  step("Installing the GLM PreToolUse hook (auto-routing) -> .github/hooks/");
+  log("  " + writeHookFile(join(WORKSPACE, ".github", "hooks")));
 }
 
 log("\n✅ Done. Next steps:");
 log("  1. Ensure GLM_API_KEY is set in " + envPath);
 log("  2. In VS Code: Reload Window, open Copilot Chat, switch to Agent mode.");
 log("  3. Start the 'glm' server: run 'MCP: List Servers' (or VS Code will offer to start it).");
-log("  4. Ask Copilot to do a coding task — it will call glm_agent. Run glm_status for the GLM usage ledger.");
+log("  4. Use it: pick the 'GLM' agent in the chat mode dropdown, or ask the main agent to");
+log("     'use glm_agent to …'. Run glm_status for the GLM usage ledger.");
 log(
   GLOBAL
-    ? "\nGLOBAL mode: the glm server + delegation policy now apply to ALL your VS Code workspaces."
+    ? "\nGLOBAL mode: the glm server, GLM subagent, delegation policy, and PreToolUse auto-routing hook now apply to ALL your VS Code workspaces."
     : "\nWorkspace mode: current project only. Re-run with --global to apply to every project."
 );

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "glm-mcp-copilot",
-  "version": "1.1.0",
-  "description": "GLM (Zhipu/Z.ai) as a cheap delegate for GitHub Copilot / Copilot Chat in VS Code — the same GLM MCP tools (glm_agent/glm_delegate/glm_recommend/glm_status) wired into VS Code agent mode.",
+  "version": "1.3.0",
+  "description": "GLM (Zhipu/Z.ai) as a cheap delegate for GitHub Copilot / Copilot Chat in VS Code — the same GLM MCP tools (glm_agent/glm_delegate/glm_recommend/glm_status), a GLM custom agent (subagent), and a PreToolUse auto-routing hook, wired into VS Code agent mode, installable globally.",
   "type": "module",
   "bin": {
     "glm-mcp-copilot": "install-copilot.mjs"
@@ -9,6 +9,9 @@
   "files": [
     "glm-mcp/",
     "install-copilot.mjs",
+    "glm_router_hook.mjs",
+    "glm.agent.md",
+    "glm.instructions.md",
     "copilot-instructions.md",
     "mcp.json.example",
     "README.md",