@rezti/dsh-rez-wechat 0.1.19 → 0.1.21

package/README.md

@@ -19,7 +19,7 @@ dsh plugin --profile web add @rezti/dsh-rez-suite
 
 - 左侧工作区分组是 **微信**，不是 Ungrouped
 - 连续消息延续同一会话
-- 模型跟网页默认（网页选了 Kimi，微信也走 Kimi）
+- 模型跟网页默认（官方默认 DeepSeek-V4-Flash；不要因为微信通道去切 Kimi）
 - 网页归档后再从微信说话会自动回到侧栏（官方会藏空白会话，所以「重启对话」会先打一句招呼）
 - 网页端选择题（Selection）会编成 `1. 2. 3.` 发到微信；回复数字或选项原文即可继续，不必在网页点选
 - 思考过程不会发到微信；多段正文会保留换行

package/lib/channel.js

@@ -167,7 +167,7 @@ export class WeixinChannel {
         if (this.runChild !== undefined && this.runChild.exitCode === null)
             return;
         this.phase = 'listening';
-        this.hint = '微信通道已在后台听着。消息会进网页「微信」文件夹的同一会话，模型跟网页默认（例如 Kimi）。';
+        this.hint = '微信通道已在后台听着。消息会进网页「微信」文件夹的同一会话，模型跟网页默认（DeepSeek-V4-Flash）。';
         const child = spawn('npx', ['-y', 'dsh-wechat-bridge', 'run', '--data-dir', DATA_DIR], {
             env: weixinRunEnv(),
             stdio: ['ignore', 'pipe', 'pipe'],

package/lib/index.js

@@ -7,7 +7,7 @@ export const name = 'rez-wechat';
 export const inject = ['systemPrompt', 'webServer', 'rezSso'];
 const GUIDANCE = [
     '企业微信有两层，不要混：① 房间消息通道 = 官方 @wecom/aibot-node-sdk（设置页 BotID + Secret 长连接），同事在企微跟哪个 bot 说话就进哪个 Harness 房间（人事/财务/法务/设计/发布/电商/实验室/老板三室），并固定同一条网页会话；只有同事说「重启对话」才新开并把旧的归档。② 办公能力 = 官方 wecom-cli >=1.1（通讯录/在线文档/在线表格/智能表格/智能文档/待办/日程/会议/邮件/微盘/消息），本企业已开通，看 rez_status.wecomCli.modules，按房间 wecomcli-* 技能执行。不要因为状态页没有企微 MCP 就说没有企微能力，也不要说「超过 10 人只能用文档」。CLI 报未授权才说该模块未开通。密钥写在 ~/.dsh/wecom-channels.json，不要写进 compose。没有绑定任何 bot 且仍配置了 REZ_WECHAT_WEBHOOK 时，才兼容旧的 wecom-mcp 群发，不要引导去填群 Webhook。不要自写 WebSocket/HTTP 客户端。',
-    '个人微信是 QClaw 同款 ClawBot 通道：在 Rez 面板「微信」页扫码一次，然后直接在微信里说话。消息进入网页左侧「微信」文件夹并延续同一会话，模型跟网页默认（在网页里选了 Kimi 就会走 Kimi）。网页端归档了也能从微信自动恢复到侧栏（空白会话网页会藏起来，所以新开的会话会先打一句招呼再出现）。网页端出现选择题时会编成纯文本发到微信，回复数字或选项原文即可；思考过程不会转发。发「重启对话」会新开一条可见的网页会话并把旧的归档。通道断了点「重新连接」（已登录不必再扫码）。不要再跑 npx weixin-mcp login，也不要调用 mcp__weixin__*。网页端必须开着。工商查询请切到法务助理，避免串房间。',
+    '个人微信是 QClaw 同款 ClawBot 通道：在 Rez 面板「微信」页扫码一次，然后直接在微信里说话。消息进入网页左侧「微信」文件夹并延续同一会话，模型跟网页默认（官方默认 DeepSeek-V4-Flash，不要因为微信去切 Kimi）。网页端归档了也能从微信自动恢复到侧栏（空白会话网页会藏起来，所以新开的会话会先打一句招呼再出现）。网页端出现选择题时会编成纯文本发到微信，回复数字或选项原文即可；思考过程不会转发。发「重启对话」会新开一条可见的网页会话并把旧的归档。通道断了点「重新连接」（已登录不必再扫码）。不要再跑 npx weixin-mcp login，也不要调用 mcp__weixin__*。网页端必须开着。工商查询请切到法务助理，避免串房间。',
     '这是 ClawBot 客服会话，不是用个人微信号管好友/群。对外发消息必须先征得用户批准。',
 ].join('');
 function isLoopbackRequest(request) {

package/lib/web-shim-cli.js

@@ -3,6 +3,10 @@
  * Executable stand-in for `dsh`. dsh-wechat-bridge spawns:
  *   $DSH_BRIDGE_DSH --profile headless <task>
  * stdout is the WeChat reply; logs go to stderr.
+ *
+ * Must process.exit: native fetch keeps the event loop alive, and the bridge
+ * holds a per-chat lock until this child exits. Without an explicit exit the
+ * first WeChat turn can reply, then every follow-up waits forever.
  */
 import { parseHeadlessArgv, runHeadlessViaWeb } from './web-shim.js';
 const parsed = parseHeadlessArgv(process.argv.slice(1));
@@ -20,3 +24,4 @@ catch (error) {
     process.stderr.write(`dsh-web-shim: ${message}\n`);
     process.stdout.write(`${message}\n`);
 }
+process.exit(0);

package/lib/web-shim.d.ts

@@ -4,8 +4,7 @@
  *
  * Headless always mints a fresh Agent (DeepSeek default, Ungrouped cwd hash).
  * Web RPC reuses one session under ~/.dsh/workspaces/微信 so the sidebar
- * folder is named 微信, turns continue, and the model follows the web default
- * (Kimi if that is what the user selected).
+ * folder is named 微信, turns continue, and the model follows the web default.
  */
 export declare const WECHAT_WORKSPACE_NAME = "\u5FAE\u4FE1";
 export declare const DEFAULT_WEB_URL = "http://127.0.0.1:3080";
@@ -75,6 +74,16 @@ export declare function ensureWechatInboxAgents(cwd: string): void;
 export declare function sessionStorePath(env?: NodeJS.ProcessEnv, home?: string): string;
 export declare function loadSessionStore(path: string): SessionStore;
 export declare function saveSessionStore(path: string, store: SessionStore): void;
+/** dsh 0.1.5+ wire endpoint is `namespace/method` (slash), not `namespace.method`. */
+export declare function normalizeRpcEndpoint(method: string): string;
+/**
+ * Typert gateway requires `{ args }` on the wire. Unary Remotes with one
+ * `request` parameter expect `{ args: { request: fields } }`; zero-arg Remotes
+ * expect `{ args: {} }`.
+ */
+export declare function wrapRemoteArgs(params: Record<string, unknown>): {
+    args: Record<string, unknown>;
+};
 export declare function encodeClientRequest(method: string, payload: Record<string, unknown>, rpcId?: string): {
     type: 'client-request';
     rpcId: string;

package/lib/web-shim.js

@@ -4,8 +4,7 @@
  *
  * Headless always mints a fresh Agent (DeepSeek default, Ungrouped cwd hash).
  * Web RPC reuses one session under ~/.dsh/workspaces/微信 so the sidebar
- * folder is named 微信, turns continue, and the model follows the web default
- * (Kimi if that is what the user selected).
+ * folder is named 微信, turns continue, and the model follows the web default.
  */
 import { randomUUID } from 'node:crypto';
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
@@ -270,8 +269,32 @@ export function saveSessionStore(path, store) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, JSON.stringify(store, null, 2), 'utf8');
 }
+/** dsh 0.1.5+ wire endpoint is `namespace/method` (slash), not `namespace.method`. */
+export function normalizeRpcEndpoint(method) {
+    if (method.includes('/'))
+        return method;
+    const dot = method.indexOf('.');
+    if (dot <= 0)
+        return method;
+    return `${method.slice(0, dot)}/${method.slice(dot + 1)}`;
+}
+/**
+ * Typert gateway requires `{ args }` on the wire. Unary Remotes with one
+ * `request` parameter expect `{ args: { request: fields } }`; zero-arg Remotes
+ * expect `{ args: {} }`.
+ */
+export function wrapRemoteArgs(params) {
+    const keys = Object.keys(params);
+    if (keys.length === 1 && keys[0] === 'args' && typeof params.args === 'object' && params.args !== null && !Array.isArray(params.args)) {
+        return { args: params.args };
+    }
+    if (keys.length === 0)
+        return { args: {} };
+    return { args: { request: params } };
+}
 export function encodeClientRequest(method, payload, rpcId = randomUUID()) {
-    return { type: 'client-request', rpcId, method, payload };
+    const endpoint = normalizeRpcEndpoint(method);
+    return { type: 'client-request', rpcId, method: endpoint, payload: wrapRemoteArgs(payload) };
 }
 export function unwrapRpc(body) {
     if (typeof body !== 'object' || body === null)
@@ -685,11 +708,21 @@ export function historyEvents(body) {
     if (typeof unwrapped !== 'object' || unwrapped === null)
         return [];
     const rec = unwrapped;
-    const raw = Array.isArray(rec.events) ? rec.events
-        : Array.isArray(rec.messages) ? rec.messages
-            : Array.isArray(rec.items) ? rec.items
-                : Array.isArray(rec.log) ? rec.log
-                    : [];
+    // 0.1.5 session/page → { records: [{ type:'event', event }] }
+    const fromRecords = Array.isArray(rec.records)
+        ? rec.records.map((row) => {
+            if (typeof row === 'object' && row !== null && row.type === 'event') {
+                return row.event ?? row;
+            }
+            return row;
+        })
+        : undefined;
+    const raw = fromRecords
+        ?? (Array.isArray(rec.events) ? rec.events
+            : Array.isArray(rec.messages) ? rec.messages
+                : Array.isArray(rec.items) ? rec.items
+                    : Array.isArray(rec.log) ? rec.log
+                        : []);
     return raw.map(unwrapHistoryItem);
 }
 export function lastAssistantText(events) {
@@ -779,7 +812,10 @@ export function pickWechatModel(models, env = process.env) {
         const provider = env.REZ_WECHAT_PROVIDER?.trim();
         return provider !== undefined && provider !== '' ? { provider, model: forced } : { model: forced };
     }
-    if (env.REZ_WECHAT_PREFER_KIMI === '0')
+    // Follow the web default (official agent-default-model is DeepSeek-V4-Flash).
+    // Do not switch a DeepSeek session onto Kimi: session/selectModel also writes
+    // the global default, so a WeChat message would make the next restart land on Kimi.
+    if (env.REZ_WECHAT_PREFER_KIMI !== '1')
         return undefined;
     const current = currentModelRef(models);
     if (current !== undefined && looksLikeKimi(`${current.provider ?? ''} ${current.model}`))
@@ -842,8 +878,9 @@ export async function postRpc(baseUrl, method, params, timeoutMs = RPC_TIMEOUT_M
             return webBaseUrl(env);
         }
     })();
-    const url = `${origin}/api/${method}`;
-    const envelope = encodeClientRequest(method, params);
+    const endpoint = normalizeRpcEndpoint(method);
+    const url = `${origin}/api/${endpoint}`;
+    const envelope = encodeClientRequest(endpoint, params);
     const send = async (cookie) => {
         const headers = { 'content-type': 'application/json' };
         if (cookie !== undefined && cookie.length > 0)
@@ -892,35 +929,28 @@ async function ensureWorkspace(rpc, cwd) {
     mkdirSync(cwd, { recursive: true });
     ensureWechatInboxAgents(cwd);
     try {
-        const created = await rpc('workspace.create', { path: cwd });
-        const id = extractWorkspaceId(created) ?? findWorkspaceId(created, cwd);
-        if (id !== undefined)
-            return id;
-    }
-    catch {
-        // create may 409 / invalid-path; list is the reconnect authority
-    }
-    try {
-        return findWorkspaceId(await rpc('workspace.list', {}), cwd);
+        // 0.1.5 workspace/create is upsert-like ({ created: boolean }); list RPC is gone.
+        const created = await rpc('workspace/create', { path: cwd });
+        return extractWorkspaceId(created) ?? findWorkspaceId(created, cwd);
     }
     catch {
         return undefined;
     }
 }
 async function createSession(rpc, cwd, workspaceId) {
-    // Official session.create accepts at most one of workspaceId / cwd.
-    // workspaceId is the one that attachSession-s into the 微信 sidebar.
+    // Official session/create accepts at most one of workspaceId / cwd.
+    // workspaceId is the one that insertSessionBefore-s into the 微信 sidebar.
     const payload = workspaceId !== undefined ? { workspaceId } : { cwd };
-    const created = await rpc('session.create', payload);
+    const created = await rpc('session/create', payload);
     const id = extractSessionId(created);
     if (id === undefined)
-        throw new Error('session.create 没有返回 sessionId');
+        throw new Error('session/create 没有返回 sessionId');
     return id;
 }
 async function maybeSelectModel(rpc, sessionId, env) {
     let models;
     try {
-        models = await rpc('session.models', { sessionId });
+        models = await rpc('session/modelCatalog', {});
     }
     catch {
         models = undefined;
@@ -930,7 +960,7 @@ async function maybeSelectModel(rpc, sessionId, env) {
         return;
     for (const payload of selectModelPayloads(sessionId, ref)) {
         try {
-            await rpc('session.selectModel', payload);
+            await rpc('session/selectModel', payload);
             return;
         }
         catch {
@@ -938,15 +968,47 @@ async function maybeSelectModel(rpc, sessionId, env) {
         }
     }
 }
+/** Prefer session/page (0.1.5 surface); fall back to session/history (apiproxy). */
+async function fetchSessionHistory(rpc, sessionId, maxMessages = 40) {
+    const attempts = [
+        {
+            method: 'session/page',
+            params: {
+                address: { kind: 'session', sessionId },
+                throughSeq: Number.MAX_SAFE_INTEGER,
+                maxMessages,
+            },
+        },
+        { method: 'session/history', params: { sessionId, maxMessages } },
+    ];
+    let lastError;
+    for (const attempt of attempts) {
+        try {
+            return historyEvents(await rpc(attempt.method, attempt.params));
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
 async function sessionAlive(rpc, sessionId) {
     try {
-        await rpc('session.history', { sessionId, maxMessages: 1 });
+        await fetchSessionHistory(rpc, sessionId, 1);
         return true;
     }
     catch {
         return false;
     }
 }
+function promptPayload(sessionId, text) {
+    return {
+        requestId: randomUUID(),
+        sessionId,
+        mode: 'queue',
+        content: [{ type: 'text', text }],
+    };
+}
 export function extractArchivedSessionIds(body) {
     const unwrapped = unwrapRpc(body);
     if (typeof unwrapped !== 'object' || unwrapped === null)
@@ -974,15 +1036,19 @@ async function tryRpc(rpc, method, params) {
 }
 /** Stock dsh archives one-way and hides blank sessions. Restore + attach + title. */
 export async function ensureSessionVisible(rpc, sessionId, env = process.env, workspaceId, loopback = true) {
-    await tryRpc(rpc, 'workspace.unarchiveSession', { sessionId });
-    await tryRpc(rpc, 'session.unarchive', { sessionId });
+    // 0.1.5 dropped unarchive/attach RPCs; insertSessionBefore is the sidebar join.
     if (loopback) {
         const workspacePath = wechatWorkspaceDir(env);
-        const url = `${webBaseUrl(env)}/api/dsh-rez-suite/weixin/unarchive`;
+        const origin = webBaseUrl(env);
+        const url = `${origin}/api/dsh-rez-suite/weixin/unarchive`;
         try {
+            const headers = { 'content-type': 'application/json' };
+            const cookie = await authCookieFor(origin, env);
+            if (cookie !== undefined)
+                headers.cookie = cookie;
             await fetch(url, {
                 method: 'POST',
-                headers: { 'content-type': 'application/json' },
+                headers,
                 body: JSON.stringify({ sessionId, workspacePath }),
                 signal: AbortSignal.timeout(3000),
             });
@@ -992,17 +1058,16 @@ export async function ensureSessionVisible(rpc, sessionId, env = process.env, wo
         }
     }
     if (workspaceId !== undefined) {
-        await tryRpc(rpc, 'workspace.attachSession', { workspaceId, sessionId });
-        await tryRpc(rpc, 'workspace.insertSessionBefore', { workspaceId, sessionId });
+        await tryRpc(rpc, 'workspace/insertSessionBefore', { workspaceId, sessionId });
     }
     const title = basename(wechatWorkspaceDir(env)) || WECHAT_WORKSPACE_NAME;
-    await tryRpc(rpc, 'session.rename', { sessionId, title });
+    await tryRpc(rpc, 'session/rename', { sessionId, title });
 }
 async function archiveSession(rpc, sessionId) {
-    await tryRpc(rpc, 'workspace.archiveSession', { sessionId });
+    await tryRpc(rpc, 'workspace/archiveSession', { sessionId });
 }
 async function abortSessionTurn(rpc, sessionId) {
-    for (const method of ['session.abort', 'session.cancel', 'session.stop', 'session.interrupt']) {
+    for (const method of ['session/cancel', 'session/abort', 'session/stop', 'session/interrupt']) {
         if (await tryRpc(rpc, method, { sessionId }))
             return;
     }
@@ -1032,7 +1097,7 @@ async function tryAnswerPendingQuestion(rpc, sessionId, choice) {
         { sessionId, answer },
         { sessionId, answers: answer.answers },
     ];
-    for (const method of ['question.respond', 'session.respondQuestion']) {
+    for (const method of ['question/respond', 'session/respondQuestion']) {
         for (const params of payloads) {
             if (await tryRpcQuick(rpc, method, params))
                 return true;
@@ -1057,7 +1122,7 @@ async function waitForAssistant(rpc, sessionId, beforeText, timeoutMs, ignorePen
     while (Date.now() < deadline) {
         let events = [];
         try {
-            events = historyEvents(await rpc('session.history', { sessionId, maxMessages: 40 }));
+            events = await fetchSessionHistory(rpc, sessionId, 40);
         }
         catch {
             events = [];
@@ -1128,7 +1193,7 @@ export async function runHeadlessViaWeb(opts) {
     let before = '';
     let events = [];
     try {
-        events = historyEvents(await rpc('session.history', { sessionId, maxMessages: 40 }));
+        events = await fetchSessionHistory(rpc, sessionId, 40);
         before = usableAssistantText(lastAssistantText(events));
     }
     catch {
@@ -1147,11 +1212,7 @@ export async function runHeadlessViaWeb(opts) {
             const answered = await tryAnswerPendingQuestion(rpc, sessionId, choice);
             if (!answered) {
                 await abortSessionTurn(rpc, sessionId);
-                await rpc('session.prompt', {
-                    sessionId,
-                    mode: 'queue',
-                    content: [{ type: 'text', text: `用户在微信选择了：${choice.label}` }],
-                });
+                await rpc('session/prompt', promptPayload(sessionId, `用户在微信选择了：${choice.label}`));
             }
             skipUserPrompt = true;
         }
@@ -1160,11 +1221,7 @@ export async function runHeadlessViaWeb(opts) {
         if (!turnIsIdle(events) || turnIsBlocked(events)) {
             await abortSessionTurn(rpc, sessionId);
         }
-        await rpc('session.prompt', {
-            sessionId,
-            mode: 'queue',
-            content: [{ type: 'text', text: promptText }],
-        });
+        await rpc('session/prompt', promptPayload(sessionId, promptText));
     }
     const reply = await waitForAssistant(rpc, sessionId, before, timeoutMs, questions, stuckAck(folder));
     store.sessions[key] = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rezti/dsh-rez-wechat",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "ReZ-TI WeChat/WeCom bridges. Personal WeChat is QClaw/ClawBot scan-and-chat via dsh-wechat-bridge; WeCom AI bots use the official @wecom/aibot-node-sdk (BotID + Secret) bound per Harness room.",
   "type": "module",
   "engines": {