@reconcrap/boss-recommend-mcp 0.1.4 → 0.1.6

package/README.md

@@ -31,6 +31,8 @@ MCP 工具名：`run_recommend_pipeline`
 - 不会对每位候选人重复确认
 - 推荐页详情处理完成后，会强制关闭详情页并确认已关闭
 - 简历提取采用“分段滚动截图 + 拼成长图”的方式，再交给多模态模型判断
+- 运行前会自动做依赖体检（Node.js、Python、Pillow、`chrome-remote-interface`、`ws`），缺失时会在 `doctor` 与流水线失败诊断中明确提示
+- 若 preflight 失败，返回 `diagnostics.recovery`（含有序修复步骤与 `agent_prompt`），可直接交给 AI agent 自动按顺序安装依赖
 
 ## 安装
 

package/package.json

@@ -1,46 +1,46 @@
-{
-  "name": "@reconcrap/boss-recommend-mcp",
-  "version": "0.1.4",
-  "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
-  "keywords": [
-    "boss",
-    "mcp",
-    "codex",
-    "recruiting",
-    "boss-zhipin",
-    "recommend"
-  ],
-  "type": "module",
-  "main": "src/index.js",
-  "bin": {
-    "boss-recommend-mcp": "bin/boss-recommend-mcp.js"
-  },
-  "scripts": {
-    "start": "node src/index.js",
-    "cli": "node src/cli.js",
-    "install:local": "node src/cli.js install",
-    "postinstall": "node scripts/postinstall.cjs",
-    "test:parser": "node src/test-parser.js",
-    "test:pipeline": "node src/test-pipeline.js"
-  },
-  "files": [
-    "bin",
-    "config/screening-config.example.json",
-    "skills",
-    "scripts/postinstall.cjs",
-    "src",
-    "vendor",
-    "README.md"
-  ],
-  "dependencies": {
-    "chrome-remote-interface": "^0.33.3",
-    "ws": "^8.19.0"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "license": "MIT"
-}
+{
+  "name": "@reconcrap/boss-recommend-mcp",
+  "version": "0.1.6",
+  "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
+  "keywords": [
+    "boss",
+    "mcp",
+    "codex",
+    "recruiting",
+    "boss-zhipin",
+    "recommend"
+  ],
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "boss-recommend-mcp": "bin/boss-recommend-mcp.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "cli": "node src/cli.js",
+    "install:local": "node src/cli.js install",
+    "postinstall": "node scripts/postinstall.cjs",
+    "test:parser": "node src/test-parser.js",
+    "test:pipeline": "node src/test-pipeline.js"
+  },
+  "files": [
+    "bin",
+    "config/screening-config.example.json",
+    "skills",
+    "scripts/postinstall.cjs",
+    "src",
+    "vendor",
+    "README.md"
+  ],
+  "dependencies": {
+    "chrome-remote-interface": "^0.33.3",
+    "ws": "^8.19.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/skills/boss-recommend-pipeline/SKILL.md

@@ -1,103 +1,124 @@
----
-name: "boss-recommend-pipeline"
-description: "Use when users ask to run Boss recommend-page filtering and screening via boss-recommend-mcp; confirm filters, criteria, optional target_count, and run-level post_action (plus max_greet_count when post_action=greet) before execution."
----
-
-# Boss Recommend Pipeline Skill
-
-## Purpose
-
-当用户希望在 Boss 推荐页按条件筛选候选人时，优先调用 MCP 工具 `run_recommend_pipeline` 完成端到端任务：
-
-1. 解析推荐页筛选指令
-2. 结构化推荐页 filters
-3. 确认筛选 criteria
-4. 在运行开始时询问 `target_count`（可选，可留空）
-5. 在运行开始时一次性确认 `post_action`
-6. 若 `post_action=greet`，同时确认 `max_greet_count`
-7. 执行 recommend-search-cli 与 recommend-screen-cli
-8. 返回结果摘要
-
-## Required Confirmation
-
-在真正执行前，必须先确认：
-
-- 学校标签（`school_tag`）
-- 学历（`degree`）
-- 性别（`gender`）
-- 是否过滤近14天已看（`recent_not_view`）
-- screening criteria 是否正确
-- `target_count`（目标筛选人数）是否需要设置（可不设上限）
-- `post_action` 是否确定为 `favorite` 或 `greet`
-- 当 `post_action=greet` 时，`max_greet_count`（最多打招呼人数）是否确定
-
-`post_action` 的确认是**单次运行级别**的：
-
-- 若用户确认 `favorite`，则本次运行中所有通过人选都统一收藏
-- 若用户确认 `greet`，则本次运行中先按 `max_greet_count` 执行打招呼，超出上限后自动改为收藏
-- 不要在每位候选人通过后再次逐个确认
-
-## Tool Contract
-
-- Tool name: `run_recommend_pipeline`
-- Input:
-  - `instruction` (required)
-  - `confirmation`
-    - `filters_confirmed`
-    - `school_tag_confirmed`
-    - `degree_confirmed`
-    - `gender_confirmed`
-    - `recent_not_view_confirmed`
-    - `criteria_confirmed`
-    - `target_count_confirmed`
-    - `target_count_value` (integer, optional)
-    - `post_action_confirmed`
-    - `post_action_value` (`favorite|greet`)
-    - `max_greet_count_confirmed`
-    - `max_greet_count_value` (integer)
-  - `overrides`
-    - `school_tag`
-    - `degree`（可传单值或数组；如“本科及以上”应展开为 `["本科","硕士","博士"]`）
-    - `gender`
-    - `recent_not_view`
-    - `criteria`
-    - `target_count`
-    - `post_action`
-    - `max_greet_count`
-
-## Execution Notes
-
-- 推荐页筛选入口在 recommend 页面，不是 search 页面。
-- recommend-search-cli 只负责应用推荐页筛选项。
-- recommend-screen-cli 负责滚动推荐列表、打开详情、提取完整简历图、调用多模态模型判断，并按单次确认的 `post_action` 执行收藏或打招呼。
-- 详情页处理完成后必须关闭详情页并确认已关闭。
-
-## Fallback
-
-如果 MCP 不可用，改用：
-
-`boss-recommend-mcp run --instruction "..." [--confirmation-json '{...}'] [--overrides-json '{...}']`
-
-CLI fallback 的状态机与 MCP 保持一致：
-
-- `NEED_INPUT`
-- `NEED_CONFIRMATION`
-- `COMPLETED`
-- `FAILED`
-
-## Setup Checklist
-
-执行前先检查：
-
-- `boss-recommend-mcp` 是否已安装
-- `screening-config.json` 是否存在且包含可用模型配置
-- Chrome 远程调试端口是否可连
-- 当前 Chrome 是否停留在 `https://www.zhipin.com/web/chat/recommend`
-
-## Response Style
-
-- 用结构化中文输出
-- 先给用户确认卡片，再正式执行
-- 对 `school_tag/degree/gender/recent_not_view` 必须逐项提问并逐项确认，不可合并成一句“filters已确认”
-- 不要跳过 `post_action` 的首轮确认
-- 不要把 recommend 流程说成 search 流程
+---
+name: "boss-recommend-pipeline"
+description: "Use when users ask to run Boss recommend-page filtering and screening via boss-recommend-mcp; confirm filters, criteria, optional target_count, and run-level post_action (plus max_greet_count when post_action=greet) before execution."
+---
+
+# Boss Recommend Pipeline Skill
+
+## Purpose
+
+当用户希望在 Boss 推荐页按条件筛选候选人时，优先调用 MCP 工具 `run_recommend_pipeline` 完成端到端任务：
+
+1. 解析推荐页筛选指令
+2. 结构化推荐页 filters
+3. 确认筛选 criteria
+4. 在运行开始时询问 `target_count`（可选，可留空）
+5. 在运行开始时一次性确认 `post_action`
+6. 若 `post_action=greet`，同时确认 `max_greet_count`
+7. 执行 recommend-search-cli 与 recommend-screen-cli
+8. 返回结果摘要
+
+## Required Confirmation
+
+在真正执行前，必须先确认：
+
+- 学校标签（`school_tag`）
+- 学历（`degree`）
+- 性别（`gender`）
+- 是否过滤近14天已看（`recent_not_view`）
+- screening criteria 是否正确
+- `target_count`（目标筛选人数）是否需要设置（可不设上限）
+- `post_action` 是否确定为 `favorite` 或 `greet`
+- 当 `post_action=greet` 时，`max_greet_count`（最多打招呼人数）是否确定
+
+`post_action` 的确认是**单次运行级别**的：
+
+- 若用户确认 `favorite`，则本次运行中所有通过人选都统一收藏
+- 若用户确认 `greet`，则本次运行中先按 `max_greet_count` 执行打招呼，超出上限后自动改为收藏
+- 不要在每位候选人通过后再次逐个确认
+
+## Tool Contract
+
+- Tool name: `run_recommend_pipeline`
+- Input:
+  - `instruction` (required)
+  - `confirmation`
+    - `filters_confirmed`
+    - `school_tag_confirmed`
+    - `degree_confirmed`
+    - `gender_confirmed`
+    - `recent_not_view_confirmed`
+    - `criteria_confirmed`
+    - `target_count_confirmed`
+    - `target_count_value` (integer, optional)
+    - `post_action_confirmed`
+    - `post_action_value` (`favorite|greet`)
+    - `max_greet_count_confirmed`
+    - `max_greet_count_value` (integer)
+  - `overrides`
+    - `school_tag`
+    - `degree`（可传单值或数组；如“本科及以上”应展开为 `["本科","硕士","博士"]`）
+    - `gender`
+    - `recent_not_view`
+    - `criteria`
+    - `target_count`
+    - `post_action`
+    - `max_greet_count`
+
+## Execution Notes
+
+- 推荐页筛选入口在 recommend 页面，不是 search 页面。
+- recommend-search-cli 只负责应用推荐页筛选项。
+- recommend-screen-cli 负责滚动推荐列表、打开详情、提取完整简历图、调用多模态模型判断，并按单次确认的 `post_action` 执行收藏或打招呼。
+- 详情页处理完成后必须关闭详情页并确认已关闭。
+
+## Fallback
+
+如果 MCP 不可用，改用：
+
+`boss-recommend-mcp run --instruction "..." [--confirmation-json '{...}'] [--overrides-json '{...}']`
+
+CLI fallback 的状态机与 MCP 保持一致：
+
+- `NEED_INPUT`
+- `NEED_CONFIRMATION`
+- `COMPLETED`
+- `FAILED`
+
+## Setup Checklist
+
+执行前先检查：
+
+- `boss-recommend-mcp` 是否已安装
+- `screening-config.json` 是否存在且包含可用模型配置
+- Chrome 远程调试端口是否可连
+- 当前 Chrome 是否停留在 `https://www.zhipin.com/web/chat/recommend`
+
+## Preflight 失败自动修复
+
+当工具返回 `status=FAILED` 且 `error.code=PIPELINE_PREFLIGHT_FAILED` 时：
+
+1. 优先读取 `diagnostics.recovery.agent_prompt`，直接把这段提示词交给 AI agent 执行环境修复。
+2. 若 `diagnostics.recovery.agent_prompt` 不存在，使用下面的兜底提示词（严格顺序，不可跳步）：
+
+```text
+你是环境修复 agent。请根据 diagnostics.checks 修复依赖，必须串行执行：
+1) 若 node_cli 失败：先安装 Node.js >=18，未成功前禁止执行 npm install。
+2) 若任意 npm_dep_* 失败：再安装 npm 依赖（chrome-remote-interface / ws）。
+3) 若 python_cli 失败：安装 Python，并确保 python 命令可用。
+4) 若 python_pillow 失败：最后执行 python -m pip install pillow。
+每一步完成后重新运行 doctor，全部通过后再重试 run_recommend_pipeline。
+```
+
+安装顺序约束（必须遵守）：
+
+- 没有 Node.js 时，不能先装 npm 包
+- 没有 Python 时，不能先装 Pillow
+
+## Response Style
+
+- 用结构化中文输出
+- 先给用户确认卡片，再正式执行
+- 对 `school_tag/degree/gender/recent_not_view` 必须逐项提问并逐项确认，不可合并成一句“filters已确认”
+- 不要跳过 `post_action` 的首轮确认
+- 不要把 recommend 流程说成 search 流程

package/src/adapters.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 const currentFilePath = fileURLToPath(import.meta.url);
@@ -174,6 +174,201 @@ function runProcess({ command, args, cwd, timeoutMs }) {
   });
 }
 
+function runProcessSync({ command, args, cwd }) {
+  try {
+    const result = spawnSync(command, args, {
+      cwd,
+      windowsHide: true,
+      shell: false,
+      env: process.env,
+      encoding: "utf8"
+    });
+    const stdout = String(result.stdout || "").trim();
+    const stderr = String(result.stderr || "").trim();
+    return {
+      ok: result.status === 0,
+      status: result.status,
+      stdout,
+      stderr,
+      output: [stdout, stderr].filter(Boolean).join("\n").trim(),
+      error_code: result.error?.code || null,
+      error_message: result.error?.message || null
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      status: -1,
+      stdout: "",
+      stderr: "",
+      output: "",
+      error_code: error.code || "SPAWN_FAILED",
+      error_message: error.message || String(error)
+    };
+  }
+}
+
+function parseMajorVersion(raw) {
+  const match = String(raw || "").match(/v?(\d+)(?:\.\d+){0,2}/);
+  if (!match) return null;
+  const major = Number.parseInt(match[1], 10);
+  return Number.isFinite(major) ? major : null;
+}
+
+function buildNodeCommandCheck() {
+  const probe = runProcessSync({
+    command: "node",
+    args: ["--version"]
+  });
+  const major = parseMajorVersion(probe.output);
+  const versionOk = Number.isInteger(major) && major >= 18;
+  return {
+    key: "node_cli",
+    ok: probe.ok && versionOk,
+    path: "node --version",
+    message: probe.ok
+      ? (versionOk
+        ? `Node 命令可用 (${probe.output || "unknown version"})`
+        : `Node 版本过低 (${probe.output || "unknown version"})，要求 >= 18`)
+      : `未找到 node 命令，请先安装 Node.js >= 18。${probe.error_message ? ` (${probe.error_message})` : ""}`
+  };
+}
+
+function detectPythonCommand() {
+  const python = runProcessSync({
+    command: "python",
+    args: ["--version"]
+  });
+  if (python.ok) {
+    return {
+      ok: true,
+      command: "python",
+      probe: python
+    };
+  }
+  const python3 = runProcessSync({
+    command: "python3",
+    args: ["--version"]
+  });
+  if (python3.ok) {
+    return {
+      ok: false,
+      command: null,
+      probe: python,
+      fallback: python3
+    };
+  }
+  return {
+    ok: false,
+    command: null,
+    probe: python,
+    fallback: null
+  };
+}
+
+function buildPythonCommandCheck() {
+  const detected = detectPythonCommand();
+  if (detected.ok) {
+    return {
+      key: "python_cli",
+      ok: true,
+      path: "python --version",
+      message: `Python 命令可用 (${detected.probe.output || "unknown version"})`
+    };
+  }
+  if (detected.fallback) {
+    return {
+      key: "python_cli",
+      ok: false,
+      path: "python --version",
+      message: `检测到 ${detected.fallback.output || "python3"}，但当前流程依赖 python 命令；请创建 python 别名后重试。`
+    };
+  }
+  return {
+    key: "python_cli",
+    ok: false,
+    path: "python --version",
+    message: "未找到 python 命令，请安装 Python 并确保 python 在 PATH 中。"
+  };
+}
+
+function buildPillowCheck() {
+  const detected = detectPythonCommand();
+  if (!detected.ok || !detected.command) {
+    return {
+      key: "python_pillow",
+      ok: false,
+      path: "python -c \"import PIL\"",
+      message: "无法校验 Pillow：python 命令不可用。"
+    };
+  }
+  const probe = runProcessSync({
+    command: detected.command,
+    args: ["-c", "import PIL, PIL.Image; print(PIL.__version__)"]
+  });
+  return {
+    key: "python_pillow",
+    ok: probe.ok,
+    path: `${detected.command} -c "import PIL"`,
+    message: probe.ok
+      ? `Pillow 可用 (${probe.output || "version unknown"})`
+      : "Pillow 未安装。请执行 `python -m pip install pillow`。"
+  };
+}
+
+function buildNodePackageCheck({ key, moduleName, cwd, missingMessage }) {
+  if (!cwd || !pathExists(cwd)) {
+    return {
+      key,
+      ok: false,
+      path: moduleName,
+      module: moduleName,
+      install_cwd: null,
+      message: missingMessage
+    };
+  }
+  const probe = runProcessSync({
+    command: "node",
+    args: ["-e", `require.resolve(${JSON.stringify(moduleName)});`],
+    cwd
+  });
+  return {
+    key,
+    ok: probe.ok,
+    path: moduleName,
+    module: moduleName,
+    install_cwd: cwd,
+    message: probe.ok
+      ? `${moduleName} npm 依赖可用`
+      : `缺少 npm 依赖 ${moduleName}，请在 boss-recommend-mcp 目录执行 npm install。`
+  };
+}
+
+function buildRuntimeDependencyChecks({ searchDir, screenDir }) {
+  return [
+    buildNodeCommandCheck(),
+    buildPythonCommandCheck(),
+    buildPillowCheck(),
+    buildNodePackageCheck({
+      key: "npm_dep_chrome_remote_interface_search",
+      moduleName: "chrome-remote-interface",
+      cwd: searchDir,
+      missingMessage: "无法校验 chrome-remote-interface：boss-recommend-search-cli 目录不存在。"
+    }),
+    buildNodePackageCheck({
+      key: "npm_dep_chrome_remote_interface_screen",
+      moduleName: "chrome-remote-interface",
+      cwd: screenDir,
+      missingMessage: "无法校验 chrome-remote-interface：boss-recommend-screen-cli 目录不存在。"
+    }),
+    buildNodePackageCheck({
+      key: "npm_dep_ws",
+      moduleName: "ws",
+      cwd: screenDir,
+      missingMessage: "无法校验 ws：boss-recommend-screen-cli 目录不存在。"
+    })
+  ];
+}
+
 function parseJsonOutput(text) {
   const trimmed = String(text || "").trim();
   if (!trimmed) return null;
@@ -248,6 +443,7 @@ export function runPipelinePreflight(workspaceRoot) {
       message: "screening-config.json 不存在"
     }
   ];
+  checks.push(...buildRuntimeDependencyChecks({ searchDir, screenDir }));
 
   return {
     ok: checks.every((item) => item.ok),

package/src/index.js

@@ -8,11 +8,18 @@ const require = createRequire(import.meta.url);
 const { version: SERVER_VERSION } = require("../package.json");
 const TOOL_NAME = "run_recommend_pipeline";
 const SERVER_NAME = "boss-recommend-mcp";
+const FRAMING_UNKNOWN = "unknown";
+const FRAMING_HEADER = "header";
+const FRAMING_LINE = "line";
 
-function writeMessage(message) {
+function writeMessage(message, framing = FRAMING_LINE) {
   const body = JSON.stringify(message);
-  const header = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n`;
-  process.stdout.write(header + body);
+  if (framing === FRAMING_HEADER) {
+    const header = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n`;
+    process.stdout.write(header + body);
+    return;
+  }
+  process.stdout.write(`${body}\n`);
 }
 
 function createJsonRpcError(id, code, message) {
@@ -219,42 +226,91 @@ export function startServer() {
   const mcpRoot = path.resolve(path.dirname(thisFile), "..");
   const workspaceRoot = envRoot ? path.resolve(envRoot) : path.resolve(mcpRoot, "..");
   let buffer = Buffer.alloc(0);
+  let framing = FRAMING_UNKNOWN;
 
   process.stdin.on("data", async (chunk) => {
     buffer = Buffer.concat([buffer, chunk]);
+    if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+      buffer = buffer.slice(3);
+    }
 
     while (true) {
-      const headerEnd = buffer.indexOf("\r\n\r\n");
-      if (headerEnd === -1) break;
+      const crlfHeaderEnd = buffer.indexOf("\r\n\r\n");
+      const lfHeaderEnd = buffer.indexOf("\n\n");
+      const crHeaderEnd = buffer.indexOf("\r\r");
+      let headerEnd = -1;
+      let headerSeparatorLength = 0;
+      if (
+        crlfHeaderEnd !== -1
+        && (lfHeaderEnd === -1 || crlfHeaderEnd < lfHeaderEnd)
+        && (crHeaderEnd === -1 || crlfHeaderEnd < crHeaderEnd)
+      ) {
+        headerEnd = crlfHeaderEnd;
+        headerSeparatorLength = 4;
+      } else if (lfHeaderEnd !== -1 && (crHeaderEnd === -1 || lfHeaderEnd < crHeaderEnd)) {
+        headerEnd = lfHeaderEnd;
+        headerSeparatorLength = 2;
+      } else if (crHeaderEnd !== -1) {
+        headerEnd = crHeaderEnd;
+        headerSeparatorLength = 2;
+      }
+      if (headerEnd !== -1) {
+        const headerText = buffer.slice(0, headerEnd).toString("utf8");
+        const contentLengthLine = headerText
+          .split(/\r\n|\n|\r/)
+          .find((line) => line.toLowerCase().startsWith("content-length:"));
 
-      const headerText = buffer.slice(0, headerEnd).toString("utf8");
-      const contentLengthLine = headerText
-        .split("\r\n")
-        .find((line) => line.toLowerCase().startsWith("content-length:"));
+        if (!contentLengthLine) {
+          buffer = buffer.slice(headerEnd + headerSeparatorLength);
+          continue;
+        }
+
+        const contentLength = Number.parseInt(contentLengthLine.split(":")[1].trim(), 10);
+        if (!Number.isFinite(contentLength) || contentLength < 0) {
+          buffer = buffer.slice(headerEnd + headerSeparatorLength);
+          continue;
+        }
 
-      if (!contentLengthLine) {
-        buffer = buffer.slice(headerEnd + 4);
+        const bodyStart = headerEnd + headerSeparatorLength;
+        const bodyEnd = bodyStart + contentLength;
+        if (buffer.length < bodyEnd) break;
+
+        const body = buffer.slice(bodyStart, bodyEnd).toString("utf8");
+        buffer = buffer.slice(bodyEnd);
+        framing = FRAMING_HEADER;
+
+        let message;
+        try {
+          message = JSON.parse(body);
+        } catch {
+          writeMessage(createJsonRpcError(null, -32700, "Parse error"), FRAMING_HEADER);
+          continue;
+        }
+
+        const response = await handleRequest(message, workspaceRoot);
+        if (response) writeMessage(response, framing);
         continue;
       }
 
-      const contentLength = Number.parseInt(contentLengthLine.split(":")[1].trim(), 10);
-      const bodyStart = headerEnd + 4;
-      const bodyEnd = bodyStart + contentLength;
-      if (buffer.length < bodyEnd) break;
-
-      const body = buffer.slice(bodyStart, bodyEnd).toString("utf8");
-      buffer = buffer.slice(bodyEnd);
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) break;
+      const rawLine = buffer.slice(0, newlineIndex).toString("utf8").replace(/\r$/, "");
+      if (/^\s*content-length:/i.test(rawLine)) break;
+      buffer = buffer.slice(newlineIndex + 1);
+      const line = rawLine.trim();
+      if (!line) continue;
+      framing = FRAMING_LINE;
 
       let message;
       try {
-        message = JSON.parse(body);
+        message = JSON.parse(line);
       } catch {
-        writeMessage(createJsonRpcError(null, -32700, "Parse error"));
+        writeMessage(createJsonRpcError(null, -32700, "Parse error"), FRAMING_LINE);
         continue;
       }
 
       const response = await handleRequest(message, workspaceRoot);
-      if (response) writeMessage(response);
+      if (response) writeMessage(response, framing);
     }
   });
 }