@xmanrui/dsh-im 4.35.1 → 4.36.1

package/src/channels/feishu/history-reader.mjs

@@ -0,0 +1,92 @@
+import { readNearbyHistory } from './nearby-history.mjs';
+import { normalizeExternalText } from './external-consumer.mjs';
+
+function refuse(code) { throw Object.assign(new Error(code), { code }); }
+function identifier(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 512;
+}
+
+function check(response) {
+  if ([230027, 99991672, 99991679].includes(response?.code)) refuse('history-permission-denied');
+  if (response?.code) refuse('history-unavailable');
+}
+
+async function checkedSdkRead(operation, signal) {
+  let response;
+  try { response = await operation(); }
+  catch (error) {
+    signal?.throwIfAborted();
+    if (error?.name === 'AbortError') throw error;
+    if (error?.code === 'ABORT_ERR' || error?.code === 'ERR_CANCELED') refuse('cancelled');
+    // The SDK rejects HTTP 403 before returning the provider's JSON payload.
+    // Never expose its raw Axios error (which can contain credential headers).
+    check(error?.response?.data);
+    refuse('history-unavailable');
+  }
+  signal?.throwIfAborted();
+  check(response);
+  return response;
+}
+
+// Application-defined checked read: destination is derived from an authenticated source.
+// Lark has Chat/time-range listing and Thread listing, not a native around-message API.
+export async function readExternalHistory(client, identity, route, query, signal) {
+  if (!route || !identifier(route.messageId) || !identifier(route.conversationId)
+    || !identifier(route.actorId) || ['threadId', 'rootId', 'parentId'].some(key => route[key] !== undefined && !identifier(route[key])) || !['group', 'nearby', 'thread'].includes(query?.scope)
+    || !Number.isInteger(query.limit) || query.limit < 1 || query.limit > 20
+    || (query.cursor !== undefined && (typeof query.cursor !== 'string' || !query.cursor || query.cursor.length > 4096)))
+    refuse('bad-request');
+  if (query.scope === 'nearby' && [query.beforeCount ?? 10, query.afterCount ?? 5]
+    .some(value => !Number.isInteger(value) || value < 0 || value > 20)) refuse('bad-request');
+  signal?.throwIfAborted();
+  const reference = await checkedSdkRead(() => client.im.v1.message.get({ path: { message_id: route.messageId }, params: { with_sender_name: true } }, { signal }), signal);
+  signal?.throwIfAborted();
+  const source = (Array.isArray(reference?.data?.items) ? reference.data.items : []).find(item => item?.message_id === route.messageId);
+  if (!source || source.deleted || source.chat_id !== route.conversationId
+    || source.sender?.sender_type !== 'user' || source.sender?.id_type !== 'open_id'
+    || source.sender?.id !== route.actorId || (source.thread_id || undefined) !== route.threadId
+    || (source.root_id || undefined) !== route.rootId || (source.parent_id || undefined) !== route.parentId)
+    refuse('stale-route');
+  if (query.scope === 'thread' && !route.threadId) refuse('thread-unavailable');
+  signal?.throwIfAborted();
+  const seconds = Math.floor(Number(source.create_time) / 1000);
+  if (!Number.isFinite(seconds) || seconds <= 0) refuse('stale-route');
+  const readPage = async params => {
+    const response = await checkedSdkRead(() => client.im.v1.message.list({ params }, { signal }), signal);
+    signal?.throwIfAborted();
+    const items = response?.data?.items;
+    if (!Array.isArray(items) || items.length > query.limit || typeof response.data.has_more !== 'boolean')
+      refuse('history-unavailable');
+    const events = [];
+    let omitted = 0;
+    for (const item of items) {
+      if (!item || item.chat_id !== route.conversationId
+        || (query.scope === 'thread' && item.thread_id !== route.threadId)) refuse('untrusted-source');
+      if (item.deleted || item.msg_type !== 'text' || item.sender?.sender_type !== 'user'
+        || item.sender?.id_type !== 'open_id') { ++omitted; continue; }
+      if (item.mentions !== undefined && (!Array.isArray(item.mentions) || item.mentions.length > 100)) { ++omitted; continue; }
+      let event;
+      try { event = normalizeExternalText({ event_id: `history:${item.message_id}`,
+        sender: { sender_type: 'user', sender_id: { open_id: item.sender.id }, sender_name: item.sender.sender_name },
+        message: { ...item, chat_type: 'group', message_type: item.msg_type, content: item.body?.content,
+          mentions: (item.mentions ?? []).map(mention => ({ ...mention, id: { open_id: mention?.id } })) },
+      }, identity); } catch (error) {
+        if (error?.code !== 'invalid-inbound') throw error;
+        ++omitted; continue;
+      }
+      if (!event) { ++omitted; continue; }
+      events.push(event);
+    }
+    const nextCursor = response.data.has_more ? response.data.page_token : undefined;
+    if (response.data.has_more && (typeof nextCursor !== 'string' || !nextCursor || nextCursor.length > 4096))
+      refuse('history-unavailable');
+    return {events, omitted, hasMore:response.data.has_more, ...(nextCursor ? {nextCursor} : {})};
+  };
+  if (query.scope === 'nearby') return readNearbyHistory(readPage, route, query, Number(source.create_time));
+  if (query.beforeCount !== undefined || query.afterCount !== undefined) refuse('bad-request');
+  const page = await readPage({container_id_type:query.scope === 'thread' ? 'thread' : 'chat',
+    container_id:query.scope === 'thread' ? route.threadId : route.conversationId,
+    sort_type:'ByCreateTimeDesc', page_size:query.limit, with_sender_name:true,
+    ...(query.cursor === undefined ? {} : {page_token:query.cursor})});
+  return {version:1, scope:query.scope, ...page, coverage:'provider-visible-human-text'};
+}

package/src/channels/feishu/multi-bot-controller.mjs

@@ -1,3 +1,4 @@
+import { ExclusiveInboundConsumers, normalizeExternalText } from './external-consumer.mjs';
 import { atConnectionStage, createConnectionDiagnostics } from '../shared/connection-error.mjs';
 import { createHash, randomUUID } from 'node:crypto';
 import { connectionTestMessage } from '../shared/connection-test.mjs';
@@ -93,6 +94,7 @@ function secretRefFor(botId) {
 function configuredBotFingerprint(config) {
   return JSON.stringify({
     id: config.id,
+    consumerMode: config.consumerMode ?? 'standalone',
     appId: config.appId,
     secretRef: config.secretRef,
     ownerOpenIds: config.ownerOpenIds,
@@ -113,6 +115,14 @@ function configuredBotFingerprint(config) {
   });
 }
 
+// Account/ownership fences must not include settings that are hot-updated on
+// the same runtime (step push, voice, slash panel or group presentation).
+function externalAccountOwnership(config) {
+  return JSON.stringify({ id: config.id, consumerMode: config.consumerMode ?? 'standalone',
+    appId: config.appId, secretRef: config.secretRef, ownerOpenIds: config.ownerOpenIds,
+    domain: config.domain, botOpenId: config.botOpenId, deletionPending: config.deletionPending === true });
+}
+
 function optionalNonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
@@ -133,6 +143,7 @@ export class MultiBotDshFeishuController {
   #createBotId;
   #createRegistrationId;
   #runtimes = new Map();
+  #inboundConsumers = new ExclusiveInboundConsumers();
   #botErrors = new Map();
   #registrations = new Map();
   #activeAppUpdates = new Map();
@@ -594,7 +605,82 @@ export class MultiBotDshFeishuController {
       this.#assertOpen('capability-unavailable');
       return { version: 1, botId, channel: 'feishu', account,
         connected: isConnected(connectionStatus(this.#runtimes.get(botId))),
-        capabilities: ['proactive-text-checked', 'proactive-receipt-checked'] };
+        capabilities: ['proactive-text-checked', 'proactive-receipt-checked', 'exclusive-text-consumer', 'reply-text-checked', 'history-text-checked', 'thread-history-text-checked'] };
+    });
+  }
+
+  async consumeInbound(botId, { expectedFingerprint, onEvent, signal } = {}) {
+    this.#assertOpen();
+    return this.#serializeConfig(() => this.#withBotTransition(botId, async () => {
+      this.#assertOpen();
+      signal?.throwIfAborted();
+      const config = this.#requireBot(botId);
+      const account = await this.#deliveryAccount(config);
+      this.#assertOpen('capability-unavailable');
+      signal?.throwIfAborted();
+      if (account.fingerprint !== expectedFingerprint)
+        throw Object.assign(new Error('account-changed'), { code: 'account-changed' });
+      const dispose = this.#inboundConsumers.register(botId, { fingerprint: expectedFingerprint, onEvent, signal });
+      try {
+        const saved = await this.#configStore.saveBot({ ...config, consumerMode: 'external-consumer' });
+        this.#assertOpen('capability-unavailable');
+        signal?.throwIfAborted();
+        const resolved = await this.#credentials.resolve(saved.secretRef);
+        this.#assertOpen('capability-unavailable');
+        signal?.throwIfAborted();
+        if (!resolved?.value) throw Object.assign(new Error('account-unverified'), { code: 'account-unverified' });
+        await this.#startRuntime(saved, resolved.value);
+        signal?.throwIfAborted();
+        this.#touch();
+        return dispose;
+      } catch (error) {
+        dispose();
+        throw error;
+      }
+    }));
+  }
+
+  async historyChecked(botId, route, query, { expectedFingerprint, signal } = {}) {
+    this.#assertOpen('capability-unavailable');
+    return this.#withBotTransition(botId, async () => {
+      this.#assertOpen('capability-unavailable');
+      signal?.throwIfAborted();
+      const config = this.#requireBot(botId);
+      const account = await this.#deliveryAccount(config);
+      this.#assertOpen('capability-unavailable');
+      signal?.throwIfAborted();
+      if (account.fingerprint !== expectedFingerprint)
+        throw Object.assign(new Error('account-changed'), { code: 'account-changed' });
+      const runtime = this.#runtimes.get(botId);
+      if (config.consumerMode !== 'external-consumer' || !isConnected(connectionStatus(runtime))
+        || typeof runtime.historyChecked !== 'function')
+        throw Object.assign(new Error('capability-unavailable'), { code: 'capability-unavailable' });
+      const leaseSignal = this.#inboundConsumers.signalFor(botId, expectedFingerprint);
+      const readSignal = signal ? AbortSignal.any([signal, leaseSignal]) : leaseSignal;
+      const result = await runtime.historyChecked({ botId, appId: config.appId,
+        botOpenId: config.botOpenId, fingerprint: account.fingerprint }, route, query, { signal: readSignal });
+      this.#assertOpen('capability-unavailable');
+      readSignal.throwIfAborted();
+      return result;
+    });
+  }
+
+  async replyChecked(botId, route, text, { expectedFingerprint, signal } = {}) {
+    this.#assertOpen();
+    return this.#withBotTransition(botId, async () => {
+      this.#assertOpen();
+      const config = this.#requireBot(botId);
+      const account = await this.#deliveryAccount(config);
+      this.#assertOpen('capability-unavailable');
+      signal?.throwIfAborted();
+      if (account.fingerprint !== expectedFingerprint)
+        throw Object.assign(new Error('account-changed'), { code: 'account-changed' });
+      signal?.throwIfAborted();
+      const runtime = this.#runtimes.get(botId);
+      if (config.consumerMode !== 'external-consumer' || !isConnected(connectionStatus(runtime))
+        || typeof runtime.replyChecked !== 'function')
+        throw Object.assign(new Error('capability-unavailable'), { code: 'capability-unavailable' });
+      return runtime.replyChecked(route, text, { signal });
     });
   }
 
@@ -628,6 +714,18 @@ export class MultiBotDshFeishuController {
     });
   }
 
+  async presentSessionSyncApproval(botId, target, interaction, options = {}) {
+    this.#assertOpen();
+    return this.#withBotTransition(botId, async () => {
+      this.#assertOpen();
+      this.#requireBot(botId);
+      const runtime = this.#runtimes.get(botId);
+      if (!isConnected(connectionStatus(runtime))
+        || typeof runtime.presentSessionSyncApproval !== 'function') return false;
+      return runtime.presentSessionSyncApproval(target, interaction, options);
+    });
+  }
+
   async disconnectBot(botId) {
     this.#assertOpen();
     // An operational pause only: credentials/config remain durable, so the
@@ -761,6 +859,7 @@ export class MultiBotDshFeishuController {
   async close() {
     if (this.#closed) return;
     this.#closed = true;
+    this.#inboundConsumers.close();
     const appUpdateProcessing = [];
     for (const record of this.#registrations.values()) {
       const state = record.manager.status().state;
@@ -1352,11 +1451,39 @@ export class MultiBotDshFeishuController {
 
   async #startRuntime(config, appSecret) {
     await this.#stopRuntime(config.id);
-    const runtime = await atConnectionStage('runtime.prepare', () => this.#createRuntime({
+    let runtime;
+    runtime = await atConnectionStage('runtime.prepare', () => this.#createRuntime({
       botId: config.id,
       config,
       appSecret,
       repair: this.#runtimeRepairCapability(config.id),
+      acceptExternal: async (event, { signal } = {}) => {
+        const assertCurrent = () => {
+          this.#assertOpen('capability-unavailable');
+          signal?.throwIfAborted();
+          if (this.#runtimes.get(config.id) !== runtime)
+            throw Object.assign(new Error('consumer-unavailable'), { code: 'consumer-unavailable' });
+          const current = this.#requireBot(config.id);
+          if (current.consumerMode !== 'external-consumer'
+            || externalAccountOwnership(current) !== externalAccountOwnership(config))
+            throw Object.assign(new Error('account-changed'), { code: 'account-changed' });
+          return current;
+        };
+        const evidence = await this.#withBotTransition(config.id, async () => {
+          const current = assertCurrent();
+          const account = await this.#deliveryAccount(current);
+          assertCurrent();
+          return normalizeExternalText(event, { botId: current.id, appId: current.appId,
+            botOpenId: current.botOpenId, fingerprint: account.fingerprint });
+        });
+        // Never hold the account queue across application work: onEvent may
+        // await a checked read/reply, and stop must be able to abort its signal.
+        assertCurrent();
+        if (evidence === null) return { accepted: true, ignored: true };
+        const result = await this.#inboundConsumers.accept(config.id, evidence, signal);
+        assertCurrent();
+        return result;
+      },
     }));
     this.#runtimes.set(config.id, runtime);
     try {
@@ -1398,6 +1525,7 @@ export class MultiBotDshFeishuController {
   async #deleteBot(botId) {
     let config = this.#configStore.getBot(botId);
     if (!config) return;
+    this.#inboundConsumers.remove(botId);
     if (!config.deletionPending) {
       config = await this.#configStore.saveBot({ ...config, deletionPending: true });
     }

package/src/channels/feishu/nearby-history.mjs

@@ -0,0 +1,72 @@
+function refuse(code) { throw Object.assign(new Error(code), { code }); }
+const count = value => Number.isInteger(value) && value >= 0 && value <= 20;
+
+export async function readNearbyHistory(readPage, route, query, anchorTime) {
+  const before = query.beforeCount ?? 10;
+  const after = query.afterCount ?? 5;
+  if (!count(before) || !count(after)) refuse('bad-request');
+  const start = Math.max(0, anchorTime - 300000);
+  const end = anchorTime + 300000;
+  const window = { start: Math.floor(start / 1000), end: Math.floor(end / 1000) + 1 };
+  let state = { phase: 'window', before: 0, after: 0 };
+  if (query.cursor !== undefined) {
+    try {
+      const decoded = JSON.parse(Buffer.from(query.cursor, 'base64url').toString());
+      if (decoded.version !== 1 || decoded.anchor !== route.messageId || decoded.at !== anchorTime
+        || decoded.minBefore !== before || decoded.minAfter !== after || decoded.limit !== query.limit
+        || !['window', 'before', 'after'].includes(decoded.phase)
+        || !count(decoded.before) || !count(decoded.after)
+        || (decoded.page !== undefined && (typeof decoded.page !== 'string' || !decoded.page || decoded.page.length > 3000)))
+        refuse('bad-request');
+      state = decoded;
+    } catch { refuse('bad-request'); }
+  }
+  const params = { container_id_type: 'chat', container_id: route.conversationId,
+    page_size: query.limit, with_sender_name: true,
+    sort_type: state.phase === 'before' ? 'ByCreateTimeDesc' : 'ByCreateTimeAsc',
+    ...(state.page === undefined ? {} : { page_token: state.page }),
+    ...(state.phase === 'window' ? { start_time: String(window.start), end_time: String(window.end) }
+      : state.phase === 'before' ? { end_time: String(window.start + 1) }
+        : { start_time: String(Math.floor(end / 1000)) }),
+  };
+  // Lark defaults an omitted end_time to now and rejects a future start_time.
+  // A fresh anchor has no existing messages beyond its future window boundary.
+  const page = state.phase === 'after' && end >= Date.now()
+    ? { events: [], omitted: 0, hasMore: false }
+    : await readPage(params);
+  const events = [];
+  for (const event of page.events) {
+    const at = Date.parse(event.at);
+    if (!Number.isFinite(at)) refuse('history-unavailable');
+    if (state.phase === 'window') {
+      if (at < start || at > end) continue;
+      events.push(event);
+      if (event.messageId !== route.messageId && at < anchorTime) state.before = Math.min(20, state.before + 1);
+      if (event.messageId !== route.messageId && at > anchorTime) state.after = Math.min(20, state.after + 1);
+    } else if (state.phase === 'before' && at < start && state.before < before) {
+      events.push(event); state.before++;
+    } else if (state.phase === 'after' && at > end && state.after < after) {
+      events.push(event); state.after++;
+    }
+  }
+  const needsPage = page.hasMore && (state.phase === 'window'
+    || (state.phase === 'before' ? state.before < before : state.after < after));
+  if (needsPage) {
+    if (page.nextCursor === state.page) refuse('history-unavailable');
+    state.page = page.nextCursor;
+  } else {
+    delete state.page;
+    if (state.phase === 'window' && state.before < before) state.phase = 'before';
+    else if (state.phase !== 'after' && state.after < after) state.phase = 'after';
+    else state.phase = 'done';
+  }
+  let nextCursor;
+  if (state.phase !== 'done') {
+    nextCursor = Buffer.from(JSON.stringify({version:1, anchor:route.messageId, at:anchorTime,
+      minBefore:before, minAfter:after, limit:query.limit, phase:state.phase,
+      before:state.before, after:state.after, ...(state.page ? {page:state.page} : {})})).toString('base64url');
+    if (nextCursor.length > 4096) refuse('history-unavailable');
+  }
+  return {version:1, scope:'nearby', events, omitted:page.omitted, hasMore:!!nextCursor,
+    ...(nextCursor ? {nextCursor} : {}), window, coverage:'provider-visible-human-text'};
+}

package/src/channels/feishu/plugin-config-store.mjs

@@ -40,6 +40,7 @@ function normalizeBot(value, { legacy = false } = {}) {
   const domain = value.domain === 'lark' ? 'lark' : 'feishu';
   return Object.freeze({
     id,
+    consumerMode: value.consumerMode === 'external-consumer' ? 'external-consumer' : 'standalone',
     appId,
     secretRef,
     ownerOpenIds: Object.freeze(ownerOpenIds),

package/src/channels/matrix/matrix-controller.mjs

@@ -224,6 +224,15 @@ export class MatrixController {
     return { sent: true };
   }
 
+  async presentSessionSyncApproval(botId, target, interaction, options = {}) {
+    this.#requireId(botId);
+    const runtime = this.#runtimes.get(botId);
+    if (!runtime?.status?.ready || typeof runtime.presentSessionSyncApproval !== 'function') {
+      throw new Error('Matrix bot is not connected for proactive delivery');
+    }
+    return runtime.presentSessionSyncApproval(target, interaction, options);
+  }
+
   async deleteBot(botId) {
     this.#requireId(botId);
     const removed = await this.#withBotTransition(botId, async () => {

package/src/channels/matrix/matrix-runtime.mjs

@@ -173,6 +173,7 @@ export class MatrixRuntime {
   #replyTimeoutMs;
   #api = null;
   #bridge = null;
+  #approvalController = new AbortController();
   #botUserId = null;
   #deviceId = null;
   #crypto = null;
@@ -289,6 +290,7 @@ export class MatrixRuntime {
   async start() {
     if (this.#started && this.#status.ready) return;
     this.#stopped = false;
+    this.#approvalController = new AbortController();
     this.#started = true;
     const generation = ++this.#generation;
     const homeserver = this.#config.homeserver;
@@ -361,6 +363,7 @@ export class MatrixRuntime {
   async stop() {
     if (this.#stopped) return;
     this.#stopped = true;
+    this.#approvalController.abort();
     this.#started = false;
     this.#generation += 1;
     if (this.#reconnectTimer !== null) clearTimeout(this.#reconnectTimer);
@@ -389,6 +392,17 @@ export class MatrixRuntime {
     return await bridge.sendConnectionTest(text);
   }
 
+  async presentSessionSyncApproval(target, interaction, options = {}) {
+    if (!this.#status.ready || !this.#bridge) return false;
+    const actor = typeof target?.route?.userId === 'string' ? target.route.userId.trim() : '';
+    if (!actor) return false;
+    return this.#bridge.presentSessionSyncApproval(interaction, {
+      key: options.key.startsWith('dm:') ? `direct:${options.key}` : options.key,
+      actor, validate: options.validate,
+      send: (text) => this.sendProactiveText(target, text),
+    }, { ...options, runtimeSignal: this.#approvalController.signal });
+  }
+
   async sendProactiveText(target, text, options = {}) {
     const api = this.#api;
     if (!api) throw new Error('Matrix bot is not connected');

package/src/channels/qq/qq-bridge.mjs

@@ -1337,6 +1337,12 @@ export class QqHarnessBridge {
     }
   }
 
+  async presentSessionSyncApproval(interaction, context, options = {}) {
+    return this.#approvals.handleSessionSyncRequested(interaction, context, {
+      ...options, runtimeSignal: this.#signal, accessPolicy: this.#accessPolicy,
+    });
+  }
+
   async #handleInteraction(interaction, {
     key,
     actor,

package/src/channels/qq/qq-controller.mjs

@@ -297,6 +297,20 @@ export class QqController {
     });
   }
 
+  async presentSessionSyncApproval(botId, target, interaction, options = {}) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown QQ bot');
+    return this.#withBotTransition(botId, async () => {
+      const runtime = this.#runtimes.get(botId);
+      if (!runtime?.status?.ready || typeof runtime.presentSessionSyncApproval !== 'function') {
+        const error = new Error(t('QQ机器人尚未连接'));
+        error.code = 'bot-not-connected';
+        throw error;
+      }
+      return runtime.presentSessionSyncApproval(target, interaction, options);
+    });
+  }
+
   async deleteBot(botId) {
     const warnings = [];
     const config = this.#configStore.get(botId);

package/src/channels/qq/qq-runtime.mjs

@@ -104,6 +104,16 @@ export class QqRuntime {
     return { sent: true };
   }
 
+  async presentSessionSyncApproval(target, interaction, options = {}) {
+    if (!this.#status.ready || !this.#bridge) return false;
+    const actor = typeof target?.route?.userOpenId === 'string' ? target.route.userOpenId.trim() : '';
+    if (!actor) return false;
+    return this.#bridge.presentSessionSyncApproval(interaction, {
+      key: options.key, actor, validate: options.validate,
+      send: (text) => this.sendProactiveText(target, text),
+    }, options);
+  }
+
   async sendProactiveText(target, text, { signal } = {}) {
     const nativeId = target?.kind === 'user'
       ? (typeof target?.route?.userOpenId === 'string' ? target.route.userOpenId.trim() : '')

package/src/channels/shared/connection-error.mjs

@@ -62,6 +62,7 @@ export function extractConnectionEvidence(error) {
       ...(reasons.length > 1 ? { reasons } : {}),
       httpStatus: errors.find(e => e.httpStatus !== undefined)?.httpStatus,
       providerCode: errors.find(e => e.providerCode !== undefined)?.providerCode,
+      method: first('method'), transport: first('transport'),
       durationMs: first('durationMs'), timeoutMs: first('timeoutMs'), host: first('host'), truncated,
     }),
   };

package/src/channels/shared/diagnostic-details.mjs

@@ -20,6 +20,12 @@ const REASONS = new Set([
   'unknown', 'multiple-causes', 'timeout', 'http-error', 'provider-rejected', 'invalid-response', 'ERR_PROXY_CONNECTION_FAILED', 'ERR_TLS_HANDSHAKE_TIMEOUT', 'ERR_SSL_TLSV1_ALERT_INTERNAL_ERROR', 'ERR_NETWORK_ACCESS_DENIED', 'AUTHENTICATIONFAILED', 'EAUTH', 'invalid-json', 'invalid-config', 'read-only',
 ]);
 const RESOURCES = new Set(['credential-store', 'account-config', 'account-state', 'workspace-config', 'workspace-directory']);
+const RPC_METHODS = new Set([
+  'host.describe', 'workspace.list', 'workspace.create', 'session.list', 'session.create',
+  'session.history', 'session.prompt', 'session.rename', 'session.cancel', 'session.models',
+  'session.permissions', 'session.selectModel', 'llm.models',
+]);
+const TRANSPORTS = new Set(['host-api', 'http']);
 const CONFIG_FILES = new Set(['config.json', 'workspaces.json']);
 export const CONFIG_ISSUE_LABELS = Object.freeze({
   'expected-object': '应为 JSON 对象。',
@@ -44,7 +50,7 @@ const CONFIG_FIELD = /^(?:\$|version|accounts(?:\[\d{1,10}\](?:\.(?:accountId|ow
 export function normalizeDiagnosticDetails(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
   const result = {};
-  for (const [field, allowed] of [['operation', OPERATIONS], ['stage', STAGES], ['reason', REASONS], ['resource', RESOURCES]]) {
+  for (const [field, allowed] of [['operation', OPERATIONS], ['stage', STAGES], ['reason', REASONS], ['resource', RESOURCES], ['method', RPC_METHODS], ['transport', TRANSPORTS]]) {
     if (allowed.has(value[field])) result[field] = value[field];
   }
   if (DIAGNOSTIC_CHANNELS.includes(value.channel)) result.channel = value.channel;