@rezti/dsh-rez-wechat 0.1.19 → 0.1.20

package/lib/web-shim.d.ts

@@ -75,6 +75,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

@@ -270,8 +270,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 +709,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) {
@@ -842,8 +876,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 +927,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 +958,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 +966,31 @@ async function maybeSelectModel(rpc, sessionId, env) {
         }
     }
 }
+/** 0.1.5 replaced session.history with session/page. */
+async function fetchSessionHistory(rpc, sessionId, maxMessages = 40) {
+    return historyEvents(await rpc('session/page', {
+        address: { kind: 'session', sessionId },
+        throughSeq: Number.MAX_SAFE_INTEGER,
+        maxMessages,
+    }));
+}
 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 +1018,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 +1040,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 +1079,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 +1104,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 +1175,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 +1194,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 +1203,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.20",
   "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": {